]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fixes for York delivery
[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 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMoveEvent swig_types[79]
2546 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNcPaintEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNotifyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxObject swig_types[83]
2550 #define SWIGTYPE_p_wxOutputStream swig_types[84]
2551 #define SWIGTYPE_p_wxPCXHandler swig_types[85]
2552 #define SWIGTYPE_p_wxPNGHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNMHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPaintEvent swig_types[88]
2555 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaperSize swig_types[90]
2557 #define SWIGTYPE_p_wxPoint swig_types[91]
2558 #define SWIGTYPE_p_wxPoint2D swig_types[92]
2559 #define SWIGTYPE_p_wxPropagateOnce swig_types[93]
2560 #define SWIGTYPE_p_wxPropagationDisabler swig_types[94]
2561 #define SWIGTYPE_p_wxPyApp swig_types[95]
2562 #define SWIGTYPE_p_wxPyCommandEvent swig_types[96]
2563 #define SWIGTYPE_p_wxPyDropTarget swig_types[97]
2564 #define SWIGTYPE_p_wxPyEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[99]
2566 #define SWIGTYPE_p_wxPyImageHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
2568 #define SWIGTYPE_p_wxPySizer swig_types[102]
2569 #define SWIGTYPE_p_wxPyValidator swig_types[103]
2570 #define SWIGTYPE_p_wxQuantize swig_types[104]
2571 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[105]
2572 #define SWIGTYPE_p_wxRealPoint swig_types[106]
2573 #define SWIGTYPE_p_wxRect swig_types[107]
2574 #define SWIGTYPE_p_wxRegion swig_types[108]
2575 #define SWIGTYPE_p_wxScrollEvent swig_types[109]
2576 #define SWIGTYPE_p_wxScrollWinEvent swig_types[110]
2577 #define SWIGTYPE_p_wxSetCursorEvent swig_types[111]
2578 #define SWIGTYPE_p_wxShowEvent swig_types[112]
2579 #define SWIGTYPE_p_wxSize swig_types[113]
2580 #define SWIGTYPE_p_wxSizeEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSizer swig_types[115]
2582 #define SWIGTYPE_p_wxSizerItem swig_types[116]
2583 #define SWIGTYPE_p_wxStaticBox swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[119]
2586 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[120]
2587 #define SWIGTYPE_p_wxTIFFHandler swig_types[121]
2588 #define SWIGTYPE_p_wxToolTip swig_types[122]
2589 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[123]
2590 #define SWIGTYPE_p_wxValidator swig_types[124]
2591 #define SWIGTYPE_p_wxVisualAttributes swig_types[125]
2592 #define SWIGTYPE_p_wxWindow swig_types[126]
2593 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[127]
2594 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[128]
2595 #define SWIGTYPE_p_wxXPMHandler swig_types[129]
2596 #define SWIGTYPE_p_wxZipFSHandler swig_types[130]
2597 static swig_type_info *swig_types[132];
2598 static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0};
2599 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2600 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2601
2602 /* -------- TYPES TABLE (END) -------- */
2603
2604 #if (PY_VERSION_HEX <= 0x02000000)
2605 # if !defined(SWIG_PYTHON_CLASSIC)
2606 # error "This python version requires to use swig with the '-classic' option"
2607 # endif
2608 #endif
2609 #if (PY_VERSION_HEX <= 0x02020000)
2610 # error "This python version requires to use swig with the '-nomodern' option"
2611 #endif
2612 #if (PY_VERSION_HEX <= 0x02020000)
2613 # error "This python version requires to use swig with the '-nomodernargs' option"
2614 #endif
2615 #ifndef METH_O
2616 # error "This python version requires to use swig with the '-nofastunpack' option"
2617 #endif
2618
2619 /*-----------------------------------------------
2620 @(target):= _core_.so
2621 ------------------------------------------------*/
2622 #define SWIG_init init_core_
2623
2624 #define SWIG_name "_core_"
2625
2626 #define SWIGVERSION 0x010329
2627
2628
2629 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2630 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2631
2632
2633 #include <stdexcept>
2634
2635
2636 namespace swig {
2637 class PyObject_ptr {
2638 protected:
2639 PyObject *_obj;
2640
2641 public:
2642 PyObject_ptr() :_obj(0)
2643 {
2644 }
2645
2646 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2647 {
2648 Py_XINCREF(_obj);
2649 }
2650
2651 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2652 {
2653 if (initial_ref) Py_XINCREF(_obj);
2654 }
2655
2656 PyObject_ptr & operator=(const PyObject_ptr& item)
2657 {
2658 Py_XINCREF(item._obj);
2659 Py_XDECREF(_obj);
2660 _obj = item._obj;
2661 return *this;
2662 }
2663
2664 ~PyObject_ptr()
2665 {
2666 Py_XDECREF(_obj);
2667 }
2668
2669 operator PyObject *() const
2670 {
2671 return _obj;
2672 }
2673
2674 PyObject *operator->() const
2675 {
2676 return _obj;
2677 }
2678 };
2679 }
2680
2681
2682 namespace swig {
2683 struct PyObject_var : PyObject_ptr {
2684 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2685
2686 PyObject_var & operator = (PyObject* obj)
2687 {
2688 Py_XDECREF(_obj);
2689 _obj = obj;
2690 return *this;
2691 }
2692 };
2693 }
2694
2695
2696 #include "wx/wxPython/wxPython_int.h"
2697 #include "wx/wxPython/pyclasses.h"
2698 #include "wx/wxPython/twoitem.h"
2699
2700
2701 #ifndef wxPyUSE_EXPORT
2702 // Helper functions for dealing with SWIG objects and such. These are
2703 // located here so they know about the SWIG types and functions declared
2704 // in the wrapper code.
2705
2706 #include <wx/hashmap.h>
2707 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2708
2709
2710 // Maintains a hashmap of className to swig_type_info pointers. Given the
2711 // name of a class either looks up the type info in the cache, or scans the
2712 // SWIG tables for it.
2713 extern PyObject* wxPyPtrTypeMap;
2714 static
2715 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2716
2717 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2718
2719 if (typeInfoCache == NULL)
2720 typeInfoCache = new wxPyTypeInfoHashMap;
2721
2722 wxString name(className);
2723 swig_type_info* swigType = (*typeInfoCache)[name];
2724
2725 if (! swigType) {
2726 // it wasn't in the cache, so look it up from SWIG
2727 name.Append(wxT(" *"));
2728 swigType = SWIG_TypeQuery(name.mb_str());
2729
2730 // if it still wasn't found, try looking for a mapped name
2731 if (!swigType) {
2732 PyObject* item;
2733 name = className;
2734
2735 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2736 (char*)(const char*)name.mbc_str())) != NULL) {
2737 name = wxString(PyString_AsString(item), *wxConvCurrent);
2738 name.Append(wxT(" *"));
2739 swigType = SWIG_TypeQuery(name.mb_str());
2740 }
2741 }
2742 if (swigType) {
2743 // and add it to the map if found
2744 (*typeInfoCache)[className] = swigType;
2745 }
2746 }
2747 return swigType;
2748 }
2749
2750
2751 // Check if a class name is a type known to SWIG
2752 bool wxPyCheckSwigType(const wxChar* className) {
2753
2754 swig_type_info* swigType = wxPyFindSwigType(className);
2755 return swigType != NULL;
2756 }
2757
2758
2759 // Given a pointer to a C++ object and a class name, construct a Python proxy
2760 // object for it.
2761 PyObject* wxPyConstructObject(void* ptr,
2762 const wxChar* className,
2763 int setThisOwn) {
2764
2765 swig_type_info* swigType = wxPyFindSwigType(className);
2766 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2767
2768 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2769 }
2770
2771
2772 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2773 // Ensures that the proxy object is of the specified (or derived) type. If
2774 // not able to perform the conversion then a Python exception is set and the
2775 // error should be handled properly in the caller. Returns True on success.
2776 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2777 const wxChar* className) {
2778
2779 swig_type_info* swigType = wxPyFindSwigType(className);
2780 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2781
2782 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2783 }
2784
2785
2786
2787 // Make a SWIGified pointer object suitable for a .this attribute
2788 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2789
2790 PyObject* robj = NULL;
2791
2792 swig_type_info* swigType = wxPyFindSwigType(className);
2793 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2794
2795 robj = PySwigObject_New(ptr, swigType, 0);
2796 return robj;
2797 }
2798
2799
2800 // Python's PyInstance_Check does not return True for instances of new-style
2801 // classes. This should get close enough for both new and old classes but I
2802 // should re-evaluate the need for doing instance checks...
2803 bool wxPyInstance_Check(PyObject* obj) {
2804 return PyObject_HasAttrString(obj, "__class__") != 0;
2805 }
2806
2807
2808 // This one checks if the object is an instance of a SWIG proxy class (it has
2809 // a .this attribute, and the .this attribute is a PySwigObject.)
2810 bool wxPySwigInstance_Check(PyObject* obj) {
2811 static PyObject* this_str = NULL;
2812 if (this_str == NULL)
2813 this_str = PyString_FromString("this");
2814
2815 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2816 if (this_attr) {
2817 bool retval = (PySwigObject_Check(this_attr) != 0);
2818 Py_DECREF(this_attr);
2819 return retval;
2820 }
2821
2822 PyErr_Clear();
2823 return false;
2824 }
2825
2826
2827 // Export a C API in a struct. Other modules will be able to load this from
2828 // the wx._core_ module and will then have safe access to these functions,
2829 // even if they are located in another shared library.
2830 static wxPyCoreAPI API = {
2831
2832 wxPyCheckSwigType,
2833 wxPyConstructObject,
2834 wxPyConvertSwigPtr,
2835 wxPyMakeSwigPtr,
2836
2837 wxPyBeginAllowThreads,
2838 wxPyEndAllowThreads,
2839 wxPyBeginBlockThreads,
2840 wxPyEndBlockThreads,
2841
2842 wxPy_ConvertList,
2843
2844 wxString_in_helper,
2845 Py2wxString,
2846 wx2PyString,
2847
2848 byte_LIST_helper,
2849 int_LIST_helper,
2850 long_LIST_helper,
2851 string_LIST_helper,
2852 wxPoint_LIST_helper,
2853 wxBitmap_LIST_helper,
2854 wxString_LIST_helper,
2855 wxAcceleratorEntry_LIST_helper,
2856
2857 wxSize_helper,
2858 wxPoint_helper,
2859 wxRealPoint_helper,
2860 wxRect_helper,
2861 wxColour_helper,
2862 wxPoint2D_helper,
2863
2864 wxPySimple_typecheck,
2865 wxColour_typecheck,
2866
2867 wxPyCBH_setCallbackInfo,
2868 wxPyCBH_findCallback,
2869 wxPyCBH_callCallback,
2870 wxPyCBH_callCallbackObj,
2871 wxPyCBH_delete,
2872
2873 wxPyMake_wxObject,
2874 wxPyMake_wxSizer,
2875 wxPyPtrTypeMap_Add,
2876 wxPy2int_seq_helper,
2877 wxPy4int_seq_helper,
2878 wxArrayString2PyList_helper,
2879 wxArrayInt2PyList_helper,
2880
2881 wxPyClientData_dtor,
2882 wxPyUserData_dtor,
2883 wxPyOORClientData_dtor,
2884
2885 wxPyCBInputStream_create,
2886 wxPyCBInputStream_copy,
2887
2888 wxPyInstance_Check,
2889 wxPySwigInstance_Check,
2890
2891 wxPyCheckForApp
2892
2893 };
2894
2895 #endif
2896
2897
2898 #if !WXWIN_COMPATIBILITY_2_4
2899 #define wxHIDE_READONLY 0
2900 #endif
2901
2902
2903 #define SWIG_From_long PyInt_FromLong
2904
2905
2906 SWIGINTERNINLINE PyObject *
2907 SWIG_From_int (int value)
2908 {
2909 return SWIG_From_long (value);
2910 }
2911
2912 static const wxString wxPyEmptyString(wxEmptyString);
2913 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2914 return self->GetClassInfo()->GetClassName();
2915 }
2916 SWIGINTERN void wxObject_Destroy(wxObject *self){
2917 delete self;
2918 }
2919
2920 #ifndef __WXMAC__
2921 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2922 #endif
2923
2924
2925 #include <limits.h>
2926 #ifndef LLONG_MIN
2927 # define LLONG_MIN LONG_LONG_MIN
2928 #endif
2929 #ifndef LLONG_MAX
2930 # define LLONG_MAX LONG_LONG_MAX
2931 #endif
2932 #ifndef ULLONG_MAX
2933 # define ULLONG_MAX ULONG_LONG_MAX
2934 #endif
2935
2936
2937 SWIGINTERN int
2938 SWIG_AsVal_long (PyObject* obj, long* val)
2939 {
2940 if (PyNumber_Check(obj)) {
2941 if (val) *val = PyInt_AsLong(obj);
2942 return SWIG_OK;
2943 }
2944 return SWIG_TypeError;
2945 }
2946
2947
2948 SWIGINTERN int
2949 SWIG_AsVal_int (PyObject * obj, int *val)
2950 {
2951 long v;
2952 int res = SWIG_AsVal_long (obj, &v);
2953 if (SWIG_IsOK(res)) {
2954 if ((v < INT_MIN || v > INT_MAX)) {
2955 return SWIG_OverflowError;
2956 } else {
2957 if (val) *val = static_cast< int >(v);
2958 }
2959 }
2960 return res;
2961 }
2962
2963 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2964 wxSize temp, *obj = &temp;
2965 if ( other == Py_None ) return false;
2966 if ( ! wxSize_helper(other, &obj) ) {
2967 PyErr_Clear();
2968 return false;
2969 }
2970 return self->operator==(*obj);
2971 }
2972 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2973 wxSize temp, *obj = &temp;
2974 if ( other == Py_None ) return true;
2975 if ( ! wxSize_helper(other, &obj)) {
2976 PyErr_Clear();
2977 return true;
2978 }
2979 return self->operator!=(*obj);
2980 }
2981 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2983 PyObject* tup = PyTuple_New(2);
2984 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2985 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2986 wxPyEndBlockThreads(blocked);
2987 return tup;
2988 }
2989
2990 SWIGINTERN int
2991 SWIG_AsVal_double (PyObject *obj, double* val)
2992 {
2993 if (PyNumber_Check(obj)) {
2994 if (val) *val = PyFloat_AsDouble(obj);
2995 return SWIG_OK;
2996 }
2997 return SWIG_TypeError;
2998 }
2999
3000
3001 #define SWIG_From_double PyFloat_FromDouble
3002
3003 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3004 wxRealPoint temp, *obj = &temp;
3005 if ( other == Py_None ) return false;
3006 if ( ! wxRealPoint_helper(other, &obj) ) {
3007 PyErr_Clear();
3008 return false;
3009 }
3010 return self->operator==(*obj);
3011 }
3012 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3013 wxRealPoint temp, *obj = &temp;
3014 if ( other == Py_None ) return true;
3015 if ( ! wxRealPoint_helper(other, &obj)) {
3016 PyErr_Clear();
3017 return true;
3018 }
3019 return self->operator!=(*obj);
3020 }
3021 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3022 self->x = x;
3023 self->y = y;
3024 }
3025 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3027 PyObject* tup = PyTuple_New(2);
3028 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3029 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3030 wxPyEndBlockThreads(blocked);
3031 return tup;
3032 }
3033 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3034 wxPoint temp, *obj = &temp;
3035 if ( other == Py_None ) return false;
3036 if ( ! wxPoint_helper(other, &obj) ) {
3037 PyErr_Clear();
3038 return false;
3039 }
3040 return self->operator==(*obj);
3041 }
3042 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3043 wxPoint temp, *obj = &temp;
3044 if ( other == Py_None ) return true;
3045 if ( ! wxPoint_helper(other, &obj)) {
3046 PyErr_Clear();
3047 return true;
3048 }
3049 return self->operator!=(*obj);
3050 }
3051 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3052 self->x = x;
3053 self->y = y;
3054 }
3055 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3057 PyObject* tup = PyTuple_New(2);
3058 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3059 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3060 wxPyEndBlockThreads(blocked);
3061 return tup;
3062 }
3063 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3064 wxRect temp, *obj = &temp;
3065 if ( other == Py_None ) return false;
3066 if ( ! wxRect_helper(other, &obj) ) {
3067 PyErr_Clear();
3068 return false;
3069 }
3070 return self->operator==(*obj);
3071 }
3072 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3073 wxRect temp, *obj = &temp;
3074 if ( other == Py_None ) return true;
3075 if ( ! wxRect_helper(other, &obj)) {
3076 PyErr_Clear();
3077 return true;
3078 }
3079 return self->operator!=(*obj);
3080 }
3081 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3082 self->x = x;
3083 self->y = y;
3084 self->width = width;
3085 self->height = height;
3086 }
3087 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3088 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3089 PyObject* tup = PyTuple_New(4);
3090 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3091 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3092 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3093 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3094 wxPyEndBlockThreads(blocked);
3095 return tup;
3096 }
3097
3098 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3099 wxRegion reg1(*r1);
3100 wxRegion reg2(*r2);
3101 wxRect dest(0,0,0,0);
3102 PyObject* obj;
3103
3104 reg1.Intersect(reg2);
3105 dest = reg1.GetBox();
3106
3107 if (dest != wxRect(0,0,0,0)) {
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 wxRect* newRect = new wxRect(dest);
3110 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3111 wxPyEndBlockThreads(blocked);
3112 return obj;
3113 }
3114 Py_INCREF(Py_None);
3115 return Py_None;
3116 }
3117
3118 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3119 wxPoint2D temp, *obj = &temp;
3120 if ( other == Py_None ) return false;
3121 if ( ! wxPoint2D_helper(other, &obj) ) {
3122 PyErr_Clear();
3123 return false;
3124 }
3125 return self->operator==(*obj);
3126 }
3127 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3128 wxPoint2D temp, *obj = &temp;
3129 if ( other == Py_None ) return true;
3130 if ( ! wxPoint2D_helper(other, &obj)) {
3131 PyErr_Clear();
3132 return true;
3133 }
3134 return self->operator!=(*obj);
3135 }
3136 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3137 self->m_x = x;
3138 self->m_y = y;
3139 }
3140 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3141 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3142 PyObject* tup = PyTuple_New(2);
3143 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3144 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3145 wxPyEndBlockThreads(blocked);
3146 return tup;
3147 }
3148
3149 #include "wx/wxPython/pyistream.h"
3150
3151 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3152 wxInputStream* wxis = wxPyCBInputStream::create(p);
3153 if (wxis)
3154 return new wxPyInputStream(wxis);
3155 else
3156 return NULL;
3157 }
3158
3159 SWIGINTERN swig_type_info*
3160 SWIG_pchar_descriptor()
3161 {
3162 static int init = 0;
3163 static swig_type_info* info = 0;
3164 if (!init) {
3165 info = SWIG_TypeQuery("_p_char");
3166 init = 1;
3167 }
3168 return info;
3169 }
3170
3171
3172 SWIGINTERNINLINE PyObject *
3173 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3174 {
3175 if (carray) {
3176 if (size > INT_MAX) {
3177 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3178 return pchar_descriptor ?
3179 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3180 } else {
3181 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3182 }
3183 } else {
3184 return SWIG_Py_Void();
3185 }
3186 }
3187
3188
3189 SWIGINTERNINLINE PyObject *
3190 SWIG_From_char (char c)
3191 {
3192 return SWIG_FromCharPtrAndSize(&c,1);
3193 }
3194
3195
3196 SWIGINTERNINLINE PyObject*
3197 SWIG_From_unsigned_SS_long (unsigned long value)
3198 {
3199 return (value > LONG_MAX) ?
3200 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3201 }
3202
3203
3204 SWIGINTERNINLINE PyObject *
3205 SWIG_From_size_t (size_t value)
3206 {
3207 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3208 }
3209
3210
3211 SWIGINTERN int
3212 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3213 {
3214 if (PyString_Check(obj)) {
3215 char *cstr; Py_ssize_t len;
3216 PyString_AsStringAndSize(obj, &cstr, &len);
3217 if (cptr) {
3218 if (alloc) {
3219 /*
3220 In python the user should not be able to modify the inner
3221 string representation. To warranty that, if you define
3222 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3223 buffer is always returned.
3224
3225 The default behavior is just to return the pointer value,
3226 so, be careful.
3227 */
3228 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3229 if (*alloc != SWIG_OLDOBJ)
3230 #else
3231 if (*alloc == SWIG_NEWOBJ)
3232 #endif
3233 {
3234 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3235 *alloc = SWIG_NEWOBJ;
3236 }
3237 else {
3238 *cptr = cstr;
3239 *alloc = SWIG_OLDOBJ;
3240 }
3241 } else {
3242 *cptr = PyString_AsString(obj);
3243 }
3244 }
3245 if (psize) *psize = len + 1;
3246 return SWIG_OK;
3247 } else {
3248 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3249 if (pchar_descriptor) {
3250 void* vptr = 0;
3251 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3252 if (cptr) *cptr = (char *) vptr;
3253 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3254 if (alloc) *alloc = SWIG_OLDOBJ;
3255 return SWIG_OK;
3256 }
3257 }
3258 }
3259 return SWIG_TypeError;
3260 }
3261
3262
3263 SWIGINTERN int
3264 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3265 {
3266 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3267 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3268 if (SWIG_IsOK(res)) {
3269 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3270 if (csize <= size) {
3271 if (val) {
3272 if (csize) memcpy(val, cptr, csize*sizeof(char));
3273 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3274 }
3275 if (alloc == SWIG_NEWOBJ) {
3276 delete[] cptr;
3277 res = SWIG_DelNewMask(res);
3278 }
3279 return res;
3280 }
3281 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3282 }
3283 return SWIG_TypeError;
3284 }
3285
3286
3287 SWIGINTERN int
3288 SWIG_AsVal_char (PyObject * obj, char *val)
3289 {
3290 int res = SWIG_AsCharArray(obj, val, 1);
3291 if (!SWIG_IsOK(res)) {
3292 long v;
3293 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3294 if (SWIG_IsOK(res)) {
3295 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3296 if (val) *val = static_cast< char >(v);
3297 } else {
3298 res = SWIG_OverflowError;
3299 }
3300 }
3301 }
3302 return res;
3303 }
3304
3305 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3306 // We use only strings for the streams, not unicode
3307 PyObject* str = PyObject_Str(obj);
3308 if (! str) {
3309 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3310 return;
3311 }
3312 self->Write(PyString_AS_STRING(str),
3313 PyString_GET_SIZE(str));
3314 Py_DECREF(str);
3315 }
3316
3317 #include "wx/wxPython/pyistream.h"
3318
3319
3320 class wxPyFileSystemHandler : public wxFileSystemHandler
3321 {
3322 public:
3323 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3324
3325 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3326 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3327 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3328 DEC_PYCALLBACK_STRING__pure(FindNext);
3329
3330 wxString GetProtocol(const wxString& location) {
3331 return wxFileSystemHandler::GetProtocol(location);
3332 }
3333
3334 wxString GetLeftLocation(const wxString& location) {
3335 return wxFileSystemHandler::GetLeftLocation(location);
3336 }
3337
3338 wxString GetAnchor(const wxString& location) {
3339 return wxFileSystemHandler::GetAnchor(location);
3340 }
3341
3342 wxString GetRightLocation(const wxString& location) {
3343 return wxFileSystemHandler::GetRightLocation(location);
3344 }
3345
3346 wxString GetMimeTypeFromExt(const wxString& location) {
3347 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3348 }
3349
3350 PYPRIVATE;
3351 };
3352
3353
3354 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3355 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3356 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3357 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3358
3359
3360 SWIGINTERN int
3361 SWIG_AsVal_bool (PyObject *obj, bool *val)
3362 {
3363 if (obj == Py_True) {
3364 if (val) *val = true;
3365 return SWIG_OK;
3366 } else if (obj == Py_False) {
3367 if (val) *val = false;
3368 return SWIG_OK;
3369 } else {
3370 long v = 0;
3371 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3372 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3373 return res;
3374 }
3375 }
3376
3377 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3378 wxFileName fname = wxFileSystem::URLToFileName(url);
3379 return fname.GetFullPath();
3380 }
3381
3382 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3383 wxImage& image,
3384 long type) {
3385 wxMemoryFSHandler::AddFile(filename, image, type);
3386 }
3387
3388 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3389 const wxBitmap& bitmap,
3390 long type) {
3391 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3392 }
3393
3394 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3395 PyObject* data) {
3396 if (! PyString_Check(data)) {
3397 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3398 "Expected string object"));
3399 return;
3400 }
3401
3402 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3403 void* ptr = (void*)PyString_AsString(data);
3404 size_t size = PyString_Size(data);
3405 wxPyEndBlockThreads(blocked);
3406
3407 wxMemoryFSHandler::AddFile(filename, ptr, size);
3408 }
3409
3410
3411 #include "wx/wxPython/pyistream.h"
3412
3413
3414 SWIGINTERN int
3415 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3416 {
3417 long v = 0;
3418 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3419 return SWIG_TypeError;
3420 }
3421 else if (val)
3422 *val = (unsigned long)v;
3423 return SWIG_OK;
3424 }
3425
3426
3427 SWIGINTERN int
3428 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3429 {
3430 unsigned long v;
3431 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3432 if (SWIG_IsOK(res)) {
3433 if ((v > UCHAR_MAX)) {
3434 return SWIG_OverflowError;
3435 } else {
3436 if (val) *val = static_cast< unsigned char >(v);
3437 }
3438 }
3439 return res;
3440 }
3441
3442
3443 SWIGINTERNINLINE PyObject *
3444 SWIG_From_unsigned_SS_char (unsigned char value)
3445 {
3446 return SWIG_From_unsigned_SS_long (value);
3447 }
3448
3449 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3450 wxImageHistogramEntry e = (*self)[key];
3451 return e.value;
3452 }
3453 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3454 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3455 wxImageHistogramEntry e = (*self)[key];
3456 return e.value;
3457 }
3458 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3459 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3460 colour.Green(),
3461 colour.Blue());
3462 wxImageHistogramEntry e = (*self)[key];
3463 return e.value;
3464 }
3465
3466 typedef unsigned char* buffer;
3467
3468
3469 // Pull the nested class out to the top level for SWIG's sake
3470 #define wxImage_RGBValue wxImage::RGBValue
3471 #define wxImage_HSVValue wxImage::HSVValue
3472
3473 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3474 if (width > 0 && height > 0)
3475 return new wxImage(width, height, clear);
3476 else
3477 return new wxImage;
3478 }
3479 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3480 return new wxImage(bitmap.ConvertToImage());
3481 }
3482 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3483 if (DATASIZE != width*height*3) {
3484 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3485 return NULL;
3486 }
3487
3488 // Copy the source data so the wxImage can clean it up later
3489 buffer copy = (buffer)malloc(DATASIZE);
3490 if (copy == NULL) {
3491 wxPyBLOCK_THREADS(PyErr_NoMemory());
3492 return NULL;
3493 }
3494 memcpy(copy, data, DATASIZE);
3495 return new wxImage(width, height, copy, false);
3496 }
3497 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3498 if (DATASIZE != width*height*3) {
3499 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3500 return NULL;
3501 }
3502 if (ALPHASIZE != width*height) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer dcopy = (buffer)malloc(DATASIZE);
3509 if (dcopy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(dcopy, data, DATASIZE);
3514
3515 buffer acopy = (buffer)malloc(ALPHASIZE);
3516 if (acopy == NULL) {
3517 wxPyBLOCK_THREADS(PyErr_NoMemory());
3518 return NULL;
3519 }
3520 memcpy(acopy, alpha, ALPHASIZE);
3521
3522 return new wxImage(width, height, dcopy, acopy, false);
3523 }
3524 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3525 wxSize size(self->GetWidth(), self->GetHeight());
3526 return size;
3527 }
3528 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3529 buffer data = self->GetData();
3530 int len = self->GetWidth() * self->GetHeight() * 3;
3531 PyObject* rv;
3532 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3533 return rv;
3534 }
3535 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3536 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3537 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3538 return;
3539 }
3540 buffer copy = (buffer)malloc(DATASIZE);
3541 if (copy == NULL) {
3542 wxPyBLOCK_THREADS(PyErr_NoMemory());
3543 return;
3544 }
3545 memcpy(copy, data, DATASIZE);
3546 self->SetData(copy, false);
3547 // wxImage takes ownership of copy...
3548 }
3549 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3550 buffer data = self->GetData();
3551 int len = self->GetWidth() * self->GetHeight() * 3;
3552 PyObject* rv;
3553 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3554 return rv;
3555 }
3556 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3557 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3558 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3559 return;
3560 }
3561 self->SetData(data, true);
3562 }
3563 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3564 buffer data = self->GetAlpha();
3565 if (! data) {
3566 RETURN_NONE();
3567 } else {
3568 int len = self->GetWidth() * self->GetHeight();
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3571 return rv;
3572 }
3573 }
3574 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3575 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3576 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3577 return;
3578 }
3579 buffer acopy = (buffer)malloc(ALPHASIZE);
3580 if (acopy == NULL) {
3581 wxPyBLOCK_THREADS(PyErr_NoMemory());
3582 return;
3583 }
3584 memcpy(acopy, alpha, ALPHASIZE);
3585 self->SetAlpha(acopy, false);
3586 // wxImage takes ownership of acopy...
3587 }
3588 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3589 buffer data = self->GetAlpha();
3590 int len = self->GetWidth() * self->GetHeight();
3591 PyObject* rv;
3592 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3593 return rv;
3594 }
3595 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3596 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3597 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3598 return;
3599 }
3600 self->SetAlpha(alpha, true);
3601 }
3602 SWIGINTERN PyObject *wxImage_GetHandlers(){
3603 wxList& list = wxImage::GetHandlers();
3604 return wxPy_ConvertList(&list);
3605 }
3606 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3607 wxBitmap bitmap(*self, depth);
3608 return bitmap;
3609 }
3610 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3611 wxImage mono = self->ConvertToMono( red, green, blue );
3612 wxBitmap bitmap( mono, 1 );
3613 return bitmap;
3614 }
3615 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3616 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3617 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3618 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3619 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3620 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3621 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3622 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3623 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3624 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3625 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3626 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3627 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3628 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3629 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3630
3631 #include <wx/quantize.h>
3632
3633 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3634 return wxQuantize::Quantize(src, dest,
3635 //NULL, // palette
3636 desiredNoColours,
3637 NULL, // eightBitData
3638 flags);
3639 }
3640 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3641 if (PyCallable_Check(func)) {
3642 self->Connect(id, lastId, eventType,
3643 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3644 new wxPyCallback(func));
3645 }
3646 else if (func == Py_None) {
3647 self->Disconnect(id, lastId, eventType,
3648 (wxObjectEventFunction)
3649 &wxPyCallback::EventThunker);
3650 }
3651 else {
3652 wxPyBLOCK_THREADS(
3653 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3654 }
3655 }
3656 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3657 return self->Disconnect(id, lastId, eventType,
3658 (wxObjectEventFunction)
3659 &wxPyCallback::EventThunker);
3660 }
3661 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3662 if (_self && _self != Py_None) {
3663 self->SetClientObject(new wxPyOORClientData(_self, incref));
3664 }
3665 else {
3666 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3667 if (data) {
3668 self->SetClientObject(NULL); // This will delete it too
3669 }
3670 }
3671 }
3672
3673 #if ! wxUSE_HOTKEY
3674 #define wxEVT_HOTKEY -9999
3675 #endif
3676
3677 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3678 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3679 if (data) {
3680 Py_INCREF(data->m_obj);
3681 return data->m_obj;
3682 } else {
3683 Py_INCREF(Py_None);
3684 return Py_None;
3685 }
3686 }
3687 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3688 wxPyClientData* data = new wxPyClientData(clientData);
3689 self->SetClientObject(data);
3690 }
3691 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3692 #if wxUSE_UNICODE
3693 return self->GetUnicodeKey();
3694 #else
3695 return 0;
3696 #endif
3697 }
3698 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3699 #if wxUSE_UNICODE
3700 self->m_uniChar = uniChar;
3701 #endif
3702 }
3703
3704 SWIGINTERNINLINE PyObject *
3705 SWIG_From_unsigned_SS_int (unsigned int value)
3706 {
3707 return SWIG_From_unsigned_SS_long (value);
3708 }
3709
3710
3711 SWIGINTERN int
3712 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3713 {
3714 unsigned long v;
3715 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3716 if (SWIG_IsOK(res)) {
3717 if ((v > UINT_MAX)) {
3718 return SWIG_OverflowError;
3719 } else {
3720 if (val) *val = static_cast< unsigned int >(v);
3721 }
3722 }
3723 return res;
3724 }
3725
3726 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3727 self->m_size = size;
3728 }
3729 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3730 int count = self->GetNumberOfFiles();
3731 wxString* files = self->GetFiles();
3732 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3733 PyObject* list = PyList_New(count);
3734
3735 if (!list) {
3736 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3737 wxPyEndBlockThreads(blocked);
3738 return NULL;
3739 }
3740
3741 for (int i=0; i<count; i++) {
3742 PyList_SetItem(list, i, wx2PyString(files[i]));
3743 }
3744 wxPyEndBlockThreads(blocked);
3745 return list;
3746 }
3747
3748
3749 SWIGINTERN wxPyApp *new_wxPyApp(){
3750 wxPythonApp = new wxPyApp();
3751 return wxPythonApp;
3752 }
3753 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3754
3755 void wxApp_CleanUp() {
3756 __wxPyCleanup();
3757 }
3758
3759
3760 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3761
3762
3763
3764
3765
3766 SWIGINTERNINLINE PyObject *
3767 SWIG_FromCharPtr(const char *cptr)
3768 {
3769 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3770 }
3771
3772
3773 #if 0 // #ifdef __WXMAC__
3774
3775 // A dummy class that raises an exception if used...
3776 class wxEventLoop
3777 {
3778 public:
3779 wxEventLoop() { wxPyRaiseNotImplemented(); }
3780 int Run() { return 0; }
3781 void Exit(int rc = 0) {}
3782 bool Pending() const { return false; }
3783 bool Dispatch() { return false; }
3784 bool IsRunning() const { return false; }
3785 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3786 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3787 };
3788
3789 #else
3790
3791 #include <wx/evtloop.h>
3792
3793 #endif
3794
3795
3796
3797 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3798 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3799 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3800 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3801 wxWindowList& list = self->GetChildren();
3802 return wxPy_ConvertList(&list);
3803 }
3804 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3805 #if wxUSE_HOTKEY
3806 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3807 #else
3808 return false;
3809 #endif
3810 }
3811 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3812
3813
3814
3815 return false;
3816
3817 }
3818 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3819 return wxPyGetWinHandle(self);
3820 }
3821 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3822 self->AssociateHandle((WXWidget)handle);
3823 }
3824 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3825
3826 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3827 return wxWindow::FindWindowById(id, parent);
3828 }
3829
3830 wxWindow* wxFindWindowByName( const wxString& name,
3831 const wxWindow *parent = NULL ) {
3832 return wxWindow::FindWindowByName(name, parent);
3833 }
3834
3835 wxWindow* wxFindWindowByLabel( const wxString& label,
3836 const wxWindow *parent = NULL ) {
3837 return wxWindow::FindWindowByLabel(label, parent);
3838 }
3839
3840
3841 #ifdef __WXMSW__
3842 #include <wx/msw/private.h> // to get wxGetWindowId
3843 #endif
3844
3845
3846 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3847 #ifdef __WXMSW__
3848 WXHWND hWnd = (WXHWND)_hWnd;
3849 long id = wxGetWindowId(hWnd);
3850 wxWindow* win = new wxWindow;
3851 if (parent)
3852 parent->AddChild(win);
3853 win->SetEventHandler(win);
3854 win->SetHWND(hWnd);
3855 win->SetId(id);
3856 win->SubclassWin(hWnd);
3857 win->AdoptAttributesFromHWND();
3858 win->SetupColours();
3859 return win;
3860 #else
3861 wxPyRaiseNotImplemented();
3862 return NULL;
3863 #endif
3864 }
3865
3866
3867 PyObject* GetTopLevelWindows() {
3868 return wxPy_ConvertList(&wxTopLevelWindows);
3869 }
3870
3871
3872 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3873 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3874 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3875
3876 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3877
3878
3879 SWIGINTERNINLINE int
3880 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3881 {
3882 unsigned long v;
3883 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3884 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3885 return res;
3886 }
3887
3888 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3889 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3890 wxMenuItemList& list = self->GetMenuItems();
3891 return wxPy_ConvertList(&list);
3892 }
3893 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3894 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3895 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3896 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3897 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3898 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3899 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3900 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3901 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3902 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3903 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3904 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3905 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3906 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3907 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3908 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3909 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3910 static const wxString wxPyControlNameStr(wxControlNameStr);
3911 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3912 if (clientData) {
3913 wxPyClientData* data = new wxPyClientData(clientData);
3914 return self->Append(item, data);
3915 } else
3916 return self->Append(item);
3917 }
3918 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3919 if (clientData) {
3920 wxPyClientData* data = new wxPyClientData(clientData);
3921 return self->Insert(item, pos, data);
3922 } else
3923 return self->Insert(item, pos);
3924 }
3925 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3926 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3927 if (data) {
3928 Py_INCREF(data->m_obj);
3929 return data->m_obj;
3930 } else {
3931 Py_INCREF(Py_None);
3932 return Py_None;
3933 }
3934 }
3935 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3936 wxPyClientData* data = new wxPyClientData(clientData);
3937 self->SetClientObject(n, data);
3938 }
3939
3940
3941 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3942 wxPyUserData* data = NULL;
3943 if ( userData ) {
3944 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3945 data = new wxPyUserData(userData);
3946 wxPyEndBlockThreads(blocked);
3947 }
3948 return new wxSizerItem(window, proportion, flag, border, data);
3949 }
3950 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3951 wxPyUserData* data = NULL;
3952 if ( userData ) {
3953 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3954 data = new wxPyUserData(userData);
3955 wxPyEndBlockThreads(blocked);
3956 }
3957 return new wxSizerItem(width, height, proportion, flag, border, data);
3958 }
3959 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3960 wxPyUserData* data = NULL;
3961 if ( userData ) {
3962 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3963 data = new wxPyUserData(userData);
3964 wxPyEndBlockThreads(blocked);
3965 }
3966 return new wxSizerItem(sizer, proportion, flag, border, data);
3967 }
3968
3969 #include <float.h>
3970
3971
3972 SWIGINTERN int
3973 SWIG_AsVal_float (PyObject * obj, float *val)
3974 {
3975 double v;
3976 int res = SWIG_AsVal_double (obj, &v);
3977 if (SWIG_IsOK(res)) {
3978 if ((v < -FLT_MAX || v > FLT_MAX)) {
3979 return SWIG_OverflowError;
3980 } else {
3981 if (val) *val = static_cast< float >(v);
3982 }
3983 }
3984 return res;
3985 }
3986
3987
3988 SWIGINTERNINLINE PyObject *
3989 SWIG_From_float (float value)
3990 {
3991 return SWIG_From_double (value);
3992 }
3993
3994 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3995 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3996 if (data) {
3997 Py_INCREF(data->m_obj);
3998 return data->m_obj;
3999 } else {
4000 Py_INCREF(Py_None);
4001 return Py_None;
4002 }
4003 }
4004 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4005 wxPyUserData* data = NULL;
4006 if ( userData ) {
4007 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4008 data = new wxPyUserData(userData);
4009 wxPyEndBlockThreads(blocked);
4010 }
4011 self->SetUserData(data);
4012 }
4013
4014 // Figure out the type of the sizer item
4015
4016 struct wxPySizerItemInfo {
4017 wxPySizerItemInfo()
4018 : window(NULL), sizer(NULL), gotSize(false),
4019 size(wxDefaultSize), gotPos(false), pos(-1)
4020 {}
4021
4022 wxWindow* window;
4023 wxSizer* sizer;
4024 bool gotSize;
4025 wxSize size;
4026 bool gotPos;
4027 int pos;
4028 };
4029
4030 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4031
4032 wxPySizerItemInfo info;
4033 wxSize size;
4034 wxSize* sizePtr = &size;
4035
4036 // Find out what the type of the item is
4037 // try wxWindow
4038 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4039 PyErr_Clear();
4040 info.window = NULL;
4041
4042 // try wxSizer
4043 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4044 PyErr_Clear();
4045 info.sizer = NULL;
4046
4047 // try wxSize or (w,h)
4048 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4049 info.size = *sizePtr;
4050 info.gotSize = true;
4051 }
4052
4053 // or a single int
4054 if (checkIdx && PyInt_Check(item)) {
4055 info.pos = PyInt_AsLong(item);
4056 info.gotPos = true;
4057 }
4058 }
4059 }
4060
4061 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4062 // no expected type, figure out what kind of error message to generate
4063 if ( !checkSize && !checkIdx )
4064 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4065 else if ( checkSize && !checkIdx )
4066 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4067 else if ( !checkSize && checkIdx)
4068 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4069 else
4070 // can this one happen?
4071 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4072 }
4073
4074 return info;
4075 }
4076
4077 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4078 if (!self->GetClientObject())
4079 self->SetClientObject(new wxPyOORClientData(_self));
4080 }
4081 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4082
4083 wxPyUserData* data = NULL;
4084 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4085 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4086 if ( userData && (info.window || info.sizer || info.gotSize) )
4087 data = new wxPyUserData(userData);
4088 if ( info.sizer )
4089 PyObject_SetAttrString(item,"thisown",Py_False);
4090 wxPyEndBlockThreads(blocked);
4091
4092 // Now call the real Add method if a valid item type was found
4093 if ( info.window )
4094 return self->Add(info.window, proportion, flag, border, data);
4095 else if ( info.sizer )
4096 return self->Add(info.sizer, proportion, flag, border, data);
4097 else if (info.gotSize)
4098 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4099 proportion, flag, border, data);
4100 else
4101 return NULL;
4102 }
4103 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4104
4105 wxPyUserData* data = NULL;
4106 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4107 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4108 if ( userData && (info.window || info.sizer || info.gotSize) )
4109 data = new wxPyUserData(userData);
4110 if ( info.sizer )
4111 PyObject_SetAttrString(item,"thisown",Py_False);
4112 wxPyEndBlockThreads(blocked);
4113
4114 // Now call the real Insert method if a valid item type was found
4115 if ( info.window )
4116 return self->Insert(before, info.window, proportion, flag, border, data);
4117 else if ( info.sizer )
4118 return self->Insert(before, info.sizer, proportion, flag, border, data);
4119 else if (info.gotSize)
4120 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4121 proportion, flag, border, data);
4122 else
4123 return NULL;
4124 }
4125 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4126
4127 wxPyUserData* data = NULL;
4128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4129 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4130 if ( userData && (info.window || info.sizer || info.gotSize) )
4131 data = new wxPyUserData(userData);
4132 if ( info.sizer )
4133 PyObject_SetAttrString(item,"thisown",Py_False);
4134 wxPyEndBlockThreads(blocked);
4135
4136 // Now call the real Prepend method if a valid item type was found
4137 if ( info.window )
4138 return self->Prepend(info.window, proportion, flag, border, data);
4139 else if ( info.sizer )
4140 return self->Prepend(info.sizer, proportion, flag, border, data);
4141 else if (info.gotSize)
4142 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4143 proportion, flag, border, data);
4144 else
4145 return NULL;
4146 }
4147 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4150 wxPyEndBlockThreads(blocked);
4151 if ( info.window )
4152 return self->Remove(info.window);
4153 else if ( info.sizer )
4154 return self->Remove(info.sizer);
4155 else if ( info.gotPos )
4156 return self->Remove(info.pos);
4157 else
4158 return false;
4159 }
4160 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4162 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4163 wxPyEndBlockThreads(blocked);
4164 if ( info.window )
4165 return self->Detach(info.window);
4166 else if ( info.sizer )
4167 return self->Detach(info.sizer);
4168 else if ( info.gotPos )
4169 return self->Detach(info.pos);
4170 else
4171 return false;
4172 }
4173 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4174 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4175 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4176 wxPyEndBlockThreads(blocked);
4177 if ( info.window )
4178 return self->GetItem(info.window);
4179 else if ( info.sizer )
4180 return self->GetItem(info.sizer);
4181 else if ( info.gotPos )
4182 return self->GetItem(info.pos);
4183 else
4184 return NULL;
4185 }
4186 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4188 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4189 wxPyEndBlockThreads(blocked);
4190 if ( info.window )
4191 self->SetItemMinSize(info.window, size);
4192 else if ( info.sizer )
4193 self->SetItemMinSize(info.sizer, size);
4194 else if ( info.gotPos )
4195 self->SetItemMinSize(info.pos, size);
4196 }
4197 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4198 wxSizerItemList& list = self->GetChildren();
4199 return wxPy_ConvertList(&list);
4200 }
4201 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4202 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4203 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4204 wxPyEndBlockThreads(blocked);
4205 if ( info.window )
4206 return self->Show(info.window, show, recursive);
4207 else if ( info.sizer )
4208 return self->Show(info.sizer, show, recursive);
4209 else if ( info.gotPos )
4210 return self->Show(info.pos, show);
4211 else
4212 return false;
4213 }
4214 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4216 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4217 wxPyEndBlockThreads(blocked);
4218 if ( info.window )
4219 return self->IsShown(info.window);
4220 else if ( info.sizer )
4221 return self->IsShown(info.sizer);
4222 else if ( info.gotPos )
4223 return self->IsShown(info.pos);
4224 else
4225 return false;
4226 }
4227
4228 // See pyclasses.h
4229 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4230 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4231 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4232
4233
4234
4235
4236 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4237 {
4238 if (source == Py_None) {
4239 **obj = wxGBPosition(-1,-1);
4240 return true;
4241 }
4242 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4243 }
4244
4245 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4246 {
4247 if (source == Py_None) {
4248 **obj = wxGBSpan(-1,-1);
4249 return true;
4250 }
4251 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4252 }
4253
4254
4255 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4256 wxGBPosition temp, *obj = &temp;
4257 if ( other == Py_None ) return false;
4258 if ( ! wxGBPosition_helper(other, &obj) ) {
4259 PyErr_Clear();
4260 return false;
4261 }
4262 return self->operator==(*obj);
4263 }
4264 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4265 wxGBPosition temp, *obj = &temp;
4266 if ( other == Py_None ) return true;
4267 if ( ! wxGBPosition_helper(other, &obj)) {
4268 PyErr_Clear();
4269 return true;
4270 }
4271 return self->operator!=(*obj);
4272 }
4273 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4274 self->SetRow(row);
4275 self->SetCol(col);
4276 }
4277 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4279 PyObject* tup = PyTuple_New(2);
4280 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4281 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4282 wxPyEndBlockThreads(blocked);
4283 return tup;
4284 }
4285 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4286 wxGBSpan temp, *obj = &temp;
4287 if ( other == Py_None ) return false;
4288 if ( ! wxGBSpan_helper(other, &obj) ) {
4289 PyErr_Clear();
4290 return false;
4291 }
4292 return self->operator==(*obj);
4293 }
4294 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4295 wxGBSpan temp, *obj = &temp;
4296 if ( other == Py_None ) return true;
4297 if ( ! wxGBSpan_helper(other, &obj)) {
4298 PyErr_Clear();
4299 return true;
4300 }
4301 return self->operator!=(*obj);
4302 }
4303 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4304 self->SetRowspan(rowspan);
4305 self->SetColspan(colspan);
4306 }
4307 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4308 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4309 PyObject* tup = PyTuple_New(2);
4310 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4311 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4312 wxPyEndBlockThreads(blocked);
4313 return tup;
4314 }
4315 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4316 wxPyUserData* data = NULL;
4317 if ( userData ) {
4318 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4319 data = new wxPyUserData(userData);
4320 wxPyEndBlockThreads(blocked);
4321 }
4322 return new wxGBSizerItem(window, pos, span, flag, border, data);
4323 }
4324 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4325 wxPyUserData* data = NULL;
4326 if ( userData ) {
4327 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4328 data = new wxPyUserData(userData);
4329 wxPyEndBlockThreads(blocked);
4330 }
4331 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4332 }
4333 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4334 wxPyUserData* data = NULL;
4335 if ( userData ) {
4336 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4337 data = new wxPyUserData(userData);
4338 wxPyEndBlockThreads(blocked);
4339 }
4340 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4341 }
4342 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4343 int row, col;
4344 self->GetEndPos(row, col);
4345 return wxGBPosition(row, col);
4346 }
4347 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4348
4349 wxPyUserData* data = NULL;
4350 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4351 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4352 if ( userData && (info.window || info.sizer || info.gotSize) )
4353 data = new wxPyUserData(userData);
4354 if ( info.sizer )
4355 PyObject_SetAttrString(item,"thisown",Py_False);
4356 wxPyEndBlockThreads(blocked);
4357
4358 // Now call the real Add method if a valid item type was found
4359 if ( info.window )
4360 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4361 else if ( info.sizer )
4362 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4363 else if (info.gotSize)
4364 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4365 pos, span, flag, border, data);
4366 return NULL;
4367 }
4368
4369
4370 #ifdef __cplusplus
4371 extern "C" {
4372 #endif
4373 SWIGINTERN int EmptyString_set(PyObject *) {
4374 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4375 return 1;
4376 }
4377
4378
4379 SWIGINTERN PyObject *EmptyString_get(void) {
4380 PyObject *pyobj = 0;
4381
4382 {
4383 #if wxUSE_UNICODE
4384 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4385 #else
4386 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4387 #endif
4388 }
4389 return pyobj;
4390 }
4391
4392
4393 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4394 PyObject *resultobj = 0;
4395 wxObject *arg1 = (wxObject *) 0 ;
4396 wxString result;
4397 void *argp1 = 0 ;
4398 int res1 = 0 ;
4399 PyObject *swig_obj[1] ;
4400
4401 if (!args) SWIG_fail;
4402 swig_obj[0] = args;
4403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4404 if (!SWIG_IsOK(res1)) {
4405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4406 }
4407 arg1 = reinterpret_cast< wxObject * >(argp1);
4408 {
4409 PyThreadState* __tstate = wxPyBeginAllowThreads();
4410 result = wxObject_GetClassName(arg1);
4411 wxPyEndAllowThreads(__tstate);
4412 if (PyErr_Occurred()) SWIG_fail;
4413 }
4414 {
4415 #if wxUSE_UNICODE
4416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4417 #else
4418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4419 #endif
4420 }
4421 return resultobj;
4422 fail:
4423 return NULL;
4424 }
4425
4426
4427 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4428 PyObject *resultobj = 0;
4429 wxObject *arg1 = (wxObject *) 0 ;
4430 void *argp1 = 0 ;
4431 int res1 = 0 ;
4432 PyObject *swig_obj[1] ;
4433
4434 if (!args) SWIG_fail;
4435 swig_obj[0] = args;
4436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4437 if (!SWIG_IsOK(res1)) {
4438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4439 }
4440 arg1 = reinterpret_cast< wxObject * >(argp1);
4441 {
4442 PyThreadState* __tstate = wxPyBeginAllowThreads();
4443 wxObject_Destroy(arg1);
4444 wxPyEndAllowThreads(__tstate);
4445 if (PyErr_Occurred()) SWIG_fail;
4446 }
4447 resultobj = SWIG_Py_Void();
4448 return resultobj;
4449 fail:
4450 return NULL;
4451 }
4452
4453
4454 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4455 PyObject *obj;
4456 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4457 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4458 return SWIG_Py_Void();
4459 }
4460
4461 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4462 PyObject *resultobj = 0;
4463 wxSize *arg1 = (wxSize *) 0 ;
4464 int arg2 ;
4465 void *argp1 = 0 ;
4466 int res1 = 0 ;
4467 int val2 ;
4468 int ecode2 = 0 ;
4469 PyObject *swig_obj[2] ;
4470
4471 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4473 if (!SWIG_IsOK(res1)) {
4474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4475 }
4476 arg1 = reinterpret_cast< wxSize * >(argp1);
4477 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4478 if (!SWIG_IsOK(ecode2)) {
4479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4480 }
4481 arg2 = static_cast< int >(val2);
4482 if (arg1) (arg1)->x = arg2;
4483
4484 resultobj = SWIG_Py_Void();
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4492 PyObject *resultobj = 0;
4493 wxSize *arg1 = (wxSize *) 0 ;
4494 int result;
4495 void *argp1 = 0 ;
4496 int res1 = 0 ;
4497 PyObject *swig_obj[1] ;
4498
4499 if (!args) SWIG_fail;
4500 swig_obj[0] = args;
4501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4502 if (!SWIG_IsOK(res1)) {
4503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4504 }
4505 arg1 = reinterpret_cast< wxSize * >(argp1);
4506 result = (int) ((arg1)->x);
4507 resultobj = SWIG_From_int(static_cast< int >(result));
4508 return resultobj;
4509 fail:
4510 return NULL;
4511 }
4512
4513
4514 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4515 PyObject *resultobj = 0;
4516 wxSize *arg1 = (wxSize *) 0 ;
4517 int arg2 ;
4518 void *argp1 = 0 ;
4519 int res1 = 0 ;
4520 int val2 ;
4521 int ecode2 = 0 ;
4522 PyObject *swig_obj[2] ;
4523
4524 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4526 if (!SWIG_IsOK(res1)) {
4527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4528 }
4529 arg1 = reinterpret_cast< wxSize * >(argp1);
4530 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4531 if (!SWIG_IsOK(ecode2)) {
4532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4533 }
4534 arg2 = static_cast< int >(val2);
4535 if (arg1) (arg1)->y = arg2;
4536
4537 resultobj = SWIG_Py_Void();
4538 return resultobj;
4539 fail:
4540 return NULL;
4541 }
4542
4543
4544 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4545 PyObject *resultobj = 0;
4546 wxSize *arg1 = (wxSize *) 0 ;
4547 int result;
4548 void *argp1 = 0 ;
4549 int res1 = 0 ;
4550 PyObject *swig_obj[1] ;
4551
4552 if (!args) SWIG_fail;
4553 swig_obj[0] = args;
4554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4555 if (!SWIG_IsOK(res1)) {
4556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4557 }
4558 arg1 = reinterpret_cast< wxSize * >(argp1);
4559 result = (int) ((arg1)->y);
4560 resultobj = SWIG_From_int(static_cast< int >(result));
4561 return resultobj;
4562 fail:
4563 return NULL;
4564 }
4565
4566
4567 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4568 PyObject *resultobj = 0;
4569 int arg1 = (int) 0 ;
4570 int arg2 = (int) 0 ;
4571 wxSize *result = 0 ;
4572 int val1 ;
4573 int ecode1 = 0 ;
4574 int val2 ;
4575 int ecode2 = 0 ;
4576 PyObject * obj0 = 0 ;
4577 PyObject * obj1 = 0 ;
4578 char * kwnames[] = {
4579 (char *) "w",(char *) "h", NULL
4580 };
4581
4582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4583 if (obj0) {
4584 ecode1 = SWIG_AsVal_int(obj0, &val1);
4585 if (!SWIG_IsOK(ecode1)) {
4586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4587 }
4588 arg1 = static_cast< int >(val1);
4589 }
4590 if (obj1) {
4591 ecode2 = SWIG_AsVal_int(obj1, &val2);
4592 if (!SWIG_IsOK(ecode2)) {
4593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4594 }
4595 arg2 = static_cast< int >(val2);
4596 }
4597 {
4598 PyThreadState* __tstate = wxPyBeginAllowThreads();
4599 result = (wxSize *)new wxSize(arg1,arg2);
4600 wxPyEndAllowThreads(__tstate);
4601 if (PyErr_Occurred()) SWIG_fail;
4602 }
4603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4604 return resultobj;
4605 fail:
4606 return NULL;
4607 }
4608
4609
4610 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4611 PyObject *resultobj = 0;
4612 wxSize *arg1 = (wxSize *) 0 ;
4613 void *argp1 = 0 ;
4614 int res1 = 0 ;
4615 PyObject *swig_obj[1] ;
4616
4617 if (!args) SWIG_fail;
4618 swig_obj[0] = args;
4619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4620 if (!SWIG_IsOK(res1)) {
4621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4622 }
4623 arg1 = reinterpret_cast< wxSize * >(argp1);
4624 {
4625 PyThreadState* __tstate = wxPyBeginAllowThreads();
4626 delete arg1;
4627
4628 wxPyEndAllowThreads(__tstate);
4629 if (PyErr_Occurred()) SWIG_fail;
4630 }
4631 resultobj = SWIG_Py_Void();
4632 return resultobj;
4633 fail:
4634 return NULL;
4635 }
4636
4637
4638 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4639 PyObject *resultobj = 0;
4640 wxSize *arg1 = (wxSize *) 0 ;
4641 PyObject *arg2 = (PyObject *) 0 ;
4642 bool result;
4643 void *argp1 = 0 ;
4644 int res1 = 0 ;
4645 PyObject * obj0 = 0 ;
4646 PyObject * obj1 = 0 ;
4647 char * kwnames[] = {
4648 (char *) "self",(char *) "other", NULL
4649 };
4650
4651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4653 if (!SWIG_IsOK(res1)) {
4654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4655 }
4656 arg1 = reinterpret_cast< wxSize * >(argp1);
4657 arg2 = obj1;
4658 {
4659 result = (bool)wxSize___eq__(arg1,arg2);
4660 if (PyErr_Occurred()) SWIG_fail;
4661 }
4662 {
4663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4664 }
4665 return resultobj;
4666 fail:
4667 return NULL;
4668 }
4669
4670
4671 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4672 PyObject *resultobj = 0;
4673 wxSize *arg1 = (wxSize *) 0 ;
4674 PyObject *arg2 = (PyObject *) 0 ;
4675 bool result;
4676 void *argp1 = 0 ;
4677 int res1 = 0 ;
4678 PyObject * obj0 = 0 ;
4679 PyObject * obj1 = 0 ;
4680 char * kwnames[] = {
4681 (char *) "self",(char *) "other", NULL
4682 };
4683
4684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4686 if (!SWIG_IsOK(res1)) {
4687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4688 }
4689 arg1 = reinterpret_cast< wxSize * >(argp1);
4690 arg2 = obj1;
4691 {
4692 result = (bool)wxSize___ne__(arg1,arg2);
4693 if (PyErr_Occurred()) SWIG_fail;
4694 }
4695 {
4696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4697 }
4698 return resultobj;
4699 fail:
4700 return NULL;
4701 }
4702
4703
4704 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4705 PyObject *resultobj = 0;
4706 wxSize *arg1 = (wxSize *) 0 ;
4707 wxSize *arg2 = 0 ;
4708 wxSize result;
4709 void *argp1 = 0 ;
4710 int res1 = 0 ;
4711 wxSize temp2 ;
4712 PyObject * obj0 = 0 ;
4713 PyObject * obj1 = 0 ;
4714 char * kwnames[] = {
4715 (char *) "self",(char *) "sz", NULL
4716 };
4717
4718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4720 if (!SWIG_IsOK(res1)) {
4721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4722 }
4723 arg1 = reinterpret_cast< wxSize * >(argp1);
4724 {
4725 arg2 = &temp2;
4726 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4727 }
4728 {
4729 PyThreadState* __tstate = wxPyBeginAllowThreads();
4730 result = (arg1)->operator +((wxSize const &)*arg2);
4731 wxPyEndAllowThreads(__tstate);
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4735 return resultobj;
4736 fail:
4737 return NULL;
4738 }
4739
4740
4741 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj = 0;
4743 wxSize *arg1 = (wxSize *) 0 ;
4744 wxSize *arg2 = 0 ;
4745 wxSize result;
4746 void *argp1 = 0 ;
4747 int res1 = 0 ;
4748 wxSize temp2 ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 char * kwnames[] = {
4752 (char *) "self",(char *) "sz", NULL
4753 };
4754
4755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4757 if (!SWIG_IsOK(res1)) {
4758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4759 }
4760 arg1 = reinterpret_cast< wxSize * >(argp1);
4761 {
4762 arg2 = &temp2;
4763 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4764 }
4765 {
4766 PyThreadState* __tstate = wxPyBeginAllowThreads();
4767 result = (arg1)->operator -((wxSize const &)*arg2);
4768 wxPyEndAllowThreads(__tstate);
4769 if (PyErr_Occurred()) SWIG_fail;
4770 }
4771 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4772 return resultobj;
4773 fail:
4774 return NULL;
4775 }
4776
4777
4778 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4779 PyObject *resultobj = 0;
4780 wxSize *arg1 = (wxSize *) 0 ;
4781 wxSize *arg2 = 0 ;
4782 void *argp1 = 0 ;
4783 int res1 = 0 ;
4784 wxSize temp2 ;
4785 PyObject * obj0 = 0 ;
4786 PyObject * obj1 = 0 ;
4787 char * kwnames[] = {
4788 (char *) "self",(char *) "sz", NULL
4789 };
4790
4791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4793 if (!SWIG_IsOK(res1)) {
4794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4795 }
4796 arg1 = reinterpret_cast< wxSize * >(argp1);
4797 {
4798 arg2 = &temp2;
4799 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4800 }
4801 {
4802 PyThreadState* __tstate = wxPyBeginAllowThreads();
4803 (arg1)->IncTo((wxSize const &)*arg2);
4804 wxPyEndAllowThreads(__tstate);
4805 if (PyErr_Occurred()) SWIG_fail;
4806 }
4807 resultobj = SWIG_Py_Void();
4808 return resultobj;
4809 fail:
4810 return NULL;
4811 }
4812
4813
4814 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4815 PyObject *resultobj = 0;
4816 wxSize *arg1 = (wxSize *) 0 ;
4817 wxSize *arg2 = 0 ;
4818 void *argp1 = 0 ;
4819 int res1 = 0 ;
4820 wxSize temp2 ;
4821 PyObject * obj0 = 0 ;
4822 PyObject * obj1 = 0 ;
4823 char * kwnames[] = {
4824 (char *) "self",(char *) "sz", NULL
4825 };
4826
4827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4829 if (!SWIG_IsOK(res1)) {
4830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4831 }
4832 arg1 = reinterpret_cast< wxSize * >(argp1);
4833 {
4834 arg2 = &temp2;
4835 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4836 }
4837 {
4838 PyThreadState* __tstate = wxPyBeginAllowThreads();
4839 (arg1)->DecTo((wxSize const &)*arg2);
4840 wxPyEndAllowThreads(__tstate);
4841 if (PyErr_Occurred()) SWIG_fail;
4842 }
4843 resultobj = SWIG_Py_Void();
4844 return resultobj;
4845 fail:
4846 return NULL;
4847 }
4848
4849
4850 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4851 PyObject *resultobj = 0;
4852 wxSize *arg1 = (wxSize *) 0 ;
4853 int arg2 ;
4854 int arg3 ;
4855 void *argp1 = 0 ;
4856 int res1 = 0 ;
4857 int val2 ;
4858 int ecode2 = 0 ;
4859 int val3 ;
4860 int ecode3 = 0 ;
4861 PyObject * obj0 = 0 ;
4862 PyObject * obj1 = 0 ;
4863 PyObject * obj2 = 0 ;
4864 char * kwnames[] = {
4865 (char *) "self",(char *) "w",(char *) "h", NULL
4866 };
4867
4868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4870 if (!SWIG_IsOK(res1)) {
4871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4872 }
4873 arg1 = reinterpret_cast< wxSize * >(argp1);
4874 ecode2 = SWIG_AsVal_int(obj1, &val2);
4875 if (!SWIG_IsOK(ecode2)) {
4876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4877 }
4878 arg2 = static_cast< int >(val2);
4879 ecode3 = SWIG_AsVal_int(obj2, &val3);
4880 if (!SWIG_IsOK(ecode3)) {
4881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4882 }
4883 arg3 = static_cast< int >(val3);
4884 {
4885 PyThreadState* __tstate = wxPyBeginAllowThreads();
4886 (arg1)->Set(arg2,arg3);
4887 wxPyEndAllowThreads(__tstate);
4888 if (PyErr_Occurred()) SWIG_fail;
4889 }
4890 resultobj = SWIG_Py_Void();
4891 return resultobj;
4892 fail:
4893 return NULL;
4894 }
4895
4896
4897 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4898 PyObject *resultobj = 0;
4899 wxSize *arg1 = (wxSize *) 0 ;
4900 int arg2 ;
4901 void *argp1 = 0 ;
4902 int res1 = 0 ;
4903 int val2 ;
4904 int ecode2 = 0 ;
4905 PyObject * obj0 = 0 ;
4906 PyObject * obj1 = 0 ;
4907 char * kwnames[] = {
4908 (char *) "self",(char *) "w", NULL
4909 };
4910
4911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4913 if (!SWIG_IsOK(res1)) {
4914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4915 }
4916 arg1 = reinterpret_cast< wxSize * >(argp1);
4917 ecode2 = SWIG_AsVal_int(obj1, &val2);
4918 if (!SWIG_IsOK(ecode2)) {
4919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4920 }
4921 arg2 = static_cast< int >(val2);
4922 {
4923 PyThreadState* __tstate = wxPyBeginAllowThreads();
4924 (arg1)->SetWidth(arg2);
4925 wxPyEndAllowThreads(__tstate);
4926 if (PyErr_Occurred()) SWIG_fail;
4927 }
4928 resultobj = SWIG_Py_Void();
4929 return resultobj;
4930 fail:
4931 return NULL;
4932 }
4933
4934
4935 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4936 PyObject *resultobj = 0;
4937 wxSize *arg1 = (wxSize *) 0 ;
4938 int arg2 ;
4939 void *argp1 = 0 ;
4940 int res1 = 0 ;
4941 int val2 ;
4942 int ecode2 = 0 ;
4943 PyObject * obj0 = 0 ;
4944 PyObject * obj1 = 0 ;
4945 char * kwnames[] = {
4946 (char *) "self",(char *) "h", NULL
4947 };
4948
4949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4951 if (!SWIG_IsOK(res1)) {
4952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4953 }
4954 arg1 = reinterpret_cast< wxSize * >(argp1);
4955 ecode2 = SWIG_AsVal_int(obj1, &val2);
4956 if (!SWIG_IsOK(ecode2)) {
4957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4958 }
4959 arg2 = static_cast< int >(val2);
4960 {
4961 PyThreadState* __tstate = wxPyBeginAllowThreads();
4962 (arg1)->SetHeight(arg2);
4963 wxPyEndAllowThreads(__tstate);
4964 if (PyErr_Occurred()) SWIG_fail;
4965 }
4966 resultobj = SWIG_Py_Void();
4967 return resultobj;
4968 fail:
4969 return NULL;
4970 }
4971
4972
4973 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4974 PyObject *resultobj = 0;
4975 wxSize *arg1 = (wxSize *) 0 ;
4976 int result;
4977 void *argp1 = 0 ;
4978 int res1 = 0 ;
4979 PyObject *swig_obj[1] ;
4980
4981 if (!args) SWIG_fail;
4982 swig_obj[0] = args;
4983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4984 if (!SWIG_IsOK(res1)) {
4985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4986 }
4987 arg1 = reinterpret_cast< wxSize * >(argp1);
4988 {
4989 PyThreadState* __tstate = wxPyBeginAllowThreads();
4990 result = (int)((wxSize const *)arg1)->GetWidth();
4991 wxPyEndAllowThreads(__tstate);
4992 if (PyErr_Occurred()) SWIG_fail;
4993 }
4994 resultobj = SWIG_From_int(static_cast< int >(result));
4995 return resultobj;
4996 fail:
4997 return NULL;
4998 }
4999
5000
5001 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5002 PyObject *resultobj = 0;
5003 wxSize *arg1 = (wxSize *) 0 ;
5004 int result;
5005 void *argp1 = 0 ;
5006 int res1 = 0 ;
5007 PyObject *swig_obj[1] ;
5008
5009 if (!args) SWIG_fail;
5010 swig_obj[0] = args;
5011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5012 if (!SWIG_IsOK(res1)) {
5013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5014 }
5015 arg1 = reinterpret_cast< wxSize * >(argp1);
5016 {
5017 PyThreadState* __tstate = wxPyBeginAllowThreads();
5018 result = (int)((wxSize const *)arg1)->GetHeight();
5019 wxPyEndAllowThreads(__tstate);
5020 if (PyErr_Occurred()) SWIG_fail;
5021 }
5022 resultobj = SWIG_From_int(static_cast< int >(result));
5023 return resultobj;
5024 fail:
5025 return NULL;
5026 }
5027
5028
5029 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5030 PyObject *resultobj = 0;
5031 wxSize *arg1 = (wxSize *) 0 ;
5032 bool result;
5033 void *argp1 = 0 ;
5034 int res1 = 0 ;
5035 PyObject *swig_obj[1] ;
5036
5037 if (!args) SWIG_fail;
5038 swig_obj[0] = args;
5039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5040 if (!SWIG_IsOK(res1)) {
5041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5042 }
5043 arg1 = reinterpret_cast< wxSize * >(argp1);
5044 {
5045 PyThreadState* __tstate = wxPyBeginAllowThreads();
5046 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5047 wxPyEndAllowThreads(__tstate);
5048 if (PyErr_Occurred()) SWIG_fail;
5049 }
5050 {
5051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5052 }
5053 return resultobj;
5054 fail:
5055 return NULL;
5056 }
5057
5058
5059 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5060 PyObject *resultobj = 0;
5061 wxSize *arg1 = (wxSize *) 0 ;
5062 wxSize *arg2 = 0 ;
5063 void *argp1 = 0 ;
5064 int res1 = 0 ;
5065 wxSize temp2 ;
5066 PyObject * obj0 = 0 ;
5067 PyObject * obj1 = 0 ;
5068 char * kwnames[] = {
5069 (char *) "self",(char *) "size", NULL
5070 };
5071
5072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5074 if (!SWIG_IsOK(res1)) {
5075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5076 }
5077 arg1 = reinterpret_cast< wxSize * >(argp1);
5078 {
5079 arg2 = &temp2;
5080 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5081 }
5082 {
5083 PyThreadState* __tstate = wxPyBeginAllowThreads();
5084 (arg1)->SetDefaults((wxSize const &)*arg2);
5085 wxPyEndAllowThreads(__tstate);
5086 if (PyErr_Occurred()) SWIG_fail;
5087 }
5088 resultobj = SWIG_Py_Void();
5089 return resultobj;
5090 fail:
5091 return NULL;
5092 }
5093
5094
5095 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5096 PyObject *resultobj = 0;
5097 wxSize *arg1 = (wxSize *) 0 ;
5098 PyObject *result = 0 ;
5099 void *argp1 = 0 ;
5100 int res1 = 0 ;
5101 PyObject *swig_obj[1] ;
5102
5103 if (!args) SWIG_fail;
5104 swig_obj[0] = args;
5105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5106 if (!SWIG_IsOK(res1)) {
5107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5108 }
5109 arg1 = reinterpret_cast< wxSize * >(argp1);
5110 {
5111 PyThreadState* __tstate = wxPyBeginAllowThreads();
5112 result = (PyObject *)wxSize_Get(arg1);
5113 wxPyEndAllowThreads(__tstate);
5114 if (PyErr_Occurred()) SWIG_fail;
5115 }
5116 resultobj = result;
5117 return resultobj;
5118 fail:
5119 return NULL;
5120 }
5121
5122
5123 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5124 PyObject *obj;
5125 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5126 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5127 return SWIG_Py_Void();
5128 }
5129
5130 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5131 return SWIG_Python_InitShadowInstance(args);
5132 }
5133
5134 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5135 PyObject *resultobj = 0;
5136 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5137 double arg2 ;
5138 void *argp1 = 0 ;
5139 int res1 = 0 ;
5140 double val2 ;
5141 int ecode2 = 0 ;
5142 PyObject *swig_obj[2] ;
5143
5144 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5146 if (!SWIG_IsOK(res1)) {
5147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5148 }
5149 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5150 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5151 if (!SWIG_IsOK(ecode2)) {
5152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5153 }
5154 arg2 = static_cast< double >(val2);
5155 if (arg1) (arg1)->x = arg2;
5156
5157 resultobj = SWIG_Py_Void();
5158 return resultobj;
5159 fail:
5160 return NULL;
5161 }
5162
5163
5164 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5165 PyObject *resultobj = 0;
5166 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5167 double result;
5168 void *argp1 = 0 ;
5169 int res1 = 0 ;
5170 PyObject *swig_obj[1] ;
5171
5172 if (!args) SWIG_fail;
5173 swig_obj[0] = args;
5174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5175 if (!SWIG_IsOK(res1)) {
5176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5177 }
5178 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5179 result = (double) ((arg1)->x);
5180 resultobj = SWIG_From_double(static_cast< double >(result));
5181 return resultobj;
5182 fail:
5183 return NULL;
5184 }
5185
5186
5187 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5188 PyObject *resultobj = 0;
5189 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5190 double arg2 ;
5191 void *argp1 = 0 ;
5192 int res1 = 0 ;
5193 double val2 ;
5194 int ecode2 = 0 ;
5195 PyObject *swig_obj[2] ;
5196
5197 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5199 if (!SWIG_IsOK(res1)) {
5200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5201 }
5202 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5203 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5204 if (!SWIG_IsOK(ecode2)) {
5205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5206 }
5207 arg2 = static_cast< double >(val2);
5208 if (arg1) (arg1)->y = arg2;
5209
5210 resultobj = SWIG_Py_Void();
5211 return resultobj;
5212 fail:
5213 return NULL;
5214 }
5215
5216
5217 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5218 PyObject *resultobj = 0;
5219 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5220 double result;
5221 void *argp1 = 0 ;
5222 int res1 = 0 ;
5223 PyObject *swig_obj[1] ;
5224
5225 if (!args) SWIG_fail;
5226 swig_obj[0] = args;
5227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5228 if (!SWIG_IsOK(res1)) {
5229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5230 }
5231 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5232 result = (double) ((arg1)->y);
5233 resultobj = SWIG_From_double(static_cast< double >(result));
5234 return resultobj;
5235 fail:
5236 return NULL;
5237 }
5238
5239
5240 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5241 PyObject *resultobj = 0;
5242 double arg1 = (double) 0.0 ;
5243 double arg2 = (double) 0.0 ;
5244 wxRealPoint *result = 0 ;
5245 double val1 ;
5246 int ecode1 = 0 ;
5247 double val2 ;
5248 int ecode2 = 0 ;
5249 PyObject * obj0 = 0 ;
5250 PyObject * obj1 = 0 ;
5251 char * kwnames[] = {
5252 (char *) "x",(char *) "y", NULL
5253 };
5254
5255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5256 if (obj0) {
5257 ecode1 = SWIG_AsVal_double(obj0, &val1);
5258 if (!SWIG_IsOK(ecode1)) {
5259 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5260 }
5261 arg1 = static_cast< double >(val1);
5262 }
5263 if (obj1) {
5264 ecode2 = SWIG_AsVal_double(obj1, &val2);
5265 if (!SWIG_IsOK(ecode2)) {
5266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5267 }
5268 arg2 = static_cast< double >(val2);
5269 }
5270 {
5271 PyThreadState* __tstate = wxPyBeginAllowThreads();
5272 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5273 wxPyEndAllowThreads(__tstate);
5274 if (PyErr_Occurred()) SWIG_fail;
5275 }
5276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5277 return resultobj;
5278 fail:
5279 return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5284 PyObject *resultobj = 0;
5285 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5286 void *argp1 = 0 ;
5287 int res1 = 0 ;
5288 PyObject *swig_obj[1] ;
5289
5290 if (!args) SWIG_fail;
5291 swig_obj[0] = args;
5292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5293 if (!SWIG_IsOK(res1)) {
5294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5295 }
5296 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5297 {
5298 PyThreadState* __tstate = wxPyBeginAllowThreads();
5299 delete arg1;
5300
5301 wxPyEndAllowThreads(__tstate);
5302 if (PyErr_Occurred()) SWIG_fail;
5303 }
5304 resultobj = SWIG_Py_Void();
5305 return resultobj;
5306 fail:
5307 return NULL;
5308 }
5309
5310
5311 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5312 PyObject *resultobj = 0;
5313 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5314 PyObject *arg2 = (PyObject *) 0 ;
5315 bool result;
5316 void *argp1 = 0 ;
5317 int res1 = 0 ;
5318 PyObject * obj0 = 0 ;
5319 PyObject * obj1 = 0 ;
5320 char * kwnames[] = {
5321 (char *) "self",(char *) "other", NULL
5322 };
5323
5324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5326 if (!SWIG_IsOK(res1)) {
5327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5328 }
5329 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5330 arg2 = obj1;
5331 {
5332 result = (bool)wxRealPoint___eq__(arg1,arg2);
5333 if (PyErr_Occurred()) SWIG_fail;
5334 }
5335 {
5336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5337 }
5338 return resultobj;
5339 fail:
5340 return NULL;
5341 }
5342
5343
5344 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5345 PyObject *resultobj = 0;
5346 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5347 PyObject *arg2 = (PyObject *) 0 ;
5348 bool result;
5349 void *argp1 = 0 ;
5350 int res1 = 0 ;
5351 PyObject * obj0 = 0 ;
5352 PyObject * obj1 = 0 ;
5353 char * kwnames[] = {
5354 (char *) "self",(char *) "other", NULL
5355 };
5356
5357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5359 if (!SWIG_IsOK(res1)) {
5360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5361 }
5362 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5363 arg2 = obj1;
5364 {
5365 result = (bool)wxRealPoint___ne__(arg1,arg2);
5366 if (PyErr_Occurred()) SWIG_fail;
5367 }
5368 {
5369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5370 }
5371 return resultobj;
5372 fail:
5373 return NULL;
5374 }
5375
5376
5377 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5378 PyObject *resultobj = 0;
5379 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5380 wxRealPoint *arg2 = 0 ;
5381 wxRealPoint result;
5382 void *argp1 = 0 ;
5383 int res1 = 0 ;
5384 wxRealPoint temp2 ;
5385 PyObject * obj0 = 0 ;
5386 PyObject * obj1 = 0 ;
5387 char * kwnames[] = {
5388 (char *) "self",(char *) "pt", NULL
5389 };
5390
5391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5393 if (!SWIG_IsOK(res1)) {
5394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5395 }
5396 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5397 {
5398 arg2 = &temp2;
5399 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5400 }
5401 {
5402 PyThreadState* __tstate = wxPyBeginAllowThreads();
5403 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5404 wxPyEndAllowThreads(__tstate);
5405 if (PyErr_Occurred()) SWIG_fail;
5406 }
5407 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5408 return resultobj;
5409 fail:
5410 return NULL;
5411 }
5412
5413
5414 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5415 PyObject *resultobj = 0;
5416 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5417 wxRealPoint *arg2 = 0 ;
5418 wxRealPoint result;
5419 void *argp1 = 0 ;
5420 int res1 = 0 ;
5421 wxRealPoint temp2 ;
5422 PyObject * obj0 = 0 ;
5423 PyObject * obj1 = 0 ;
5424 char * kwnames[] = {
5425 (char *) "self",(char *) "pt", NULL
5426 };
5427
5428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5430 if (!SWIG_IsOK(res1)) {
5431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5432 }
5433 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5434 {
5435 arg2 = &temp2;
5436 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5437 }
5438 {
5439 PyThreadState* __tstate = wxPyBeginAllowThreads();
5440 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5441 wxPyEndAllowThreads(__tstate);
5442 if (PyErr_Occurred()) SWIG_fail;
5443 }
5444 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5445 return resultobj;
5446 fail:
5447 return NULL;
5448 }
5449
5450
5451 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5452 PyObject *resultobj = 0;
5453 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5454 double arg2 ;
5455 double arg3 ;
5456 void *argp1 = 0 ;
5457 int res1 = 0 ;
5458 double val2 ;
5459 int ecode2 = 0 ;
5460 double val3 ;
5461 int ecode3 = 0 ;
5462 PyObject * obj0 = 0 ;
5463 PyObject * obj1 = 0 ;
5464 PyObject * obj2 = 0 ;
5465 char * kwnames[] = {
5466 (char *) "self",(char *) "x",(char *) "y", NULL
5467 };
5468
5469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5471 if (!SWIG_IsOK(res1)) {
5472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5473 }
5474 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5475 ecode2 = SWIG_AsVal_double(obj1, &val2);
5476 if (!SWIG_IsOK(ecode2)) {
5477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5478 }
5479 arg2 = static_cast< double >(val2);
5480 ecode3 = SWIG_AsVal_double(obj2, &val3);
5481 if (!SWIG_IsOK(ecode3)) {
5482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5483 }
5484 arg3 = static_cast< double >(val3);
5485 {
5486 PyThreadState* __tstate = wxPyBeginAllowThreads();
5487 wxRealPoint_Set(arg1,arg2,arg3);
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 resultobj = SWIG_Py_Void();
5492 return resultobj;
5493 fail:
5494 return NULL;
5495 }
5496
5497
5498 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5499 PyObject *resultobj = 0;
5500 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5501 PyObject *result = 0 ;
5502 void *argp1 = 0 ;
5503 int res1 = 0 ;
5504 PyObject *swig_obj[1] ;
5505
5506 if (!args) SWIG_fail;
5507 swig_obj[0] = args;
5508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5509 if (!SWIG_IsOK(res1)) {
5510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5511 }
5512 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5513 {
5514 PyThreadState* __tstate = wxPyBeginAllowThreads();
5515 result = (PyObject *)wxRealPoint_Get(arg1);
5516 wxPyEndAllowThreads(__tstate);
5517 if (PyErr_Occurred()) SWIG_fail;
5518 }
5519 resultobj = result;
5520 return resultobj;
5521 fail:
5522 return NULL;
5523 }
5524
5525
5526 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5527 PyObject *obj;
5528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5529 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5530 return SWIG_Py_Void();
5531 }
5532
5533 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5534 return SWIG_Python_InitShadowInstance(args);
5535 }
5536
5537 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5538 PyObject *resultobj = 0;
5539 wxPoint *arg1 = (wxPoint *) 0 ;
5540 int arg2 ;
5541 void *argp1 = 0 ;
5542 int res1 = 0 ;
5543 int val2 ;
5544 int ecode2 = 0 ;
5545 PyObject *swig_obj[2] ;
5546
5547 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5549 if (!SWIG_IsOK(res1)) {
5550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5551 }
5552 arg1 = reinterpret_cast< wxPoint * >(argp1);
5553 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5554 if (!SWIG_IsOK(ecode2)) {
5555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5556 }
5557 arg2 = static_cast< int >(val2);
5558 if (arg1) (arg1)->x = arg2;
5559
5560 resultobj = SWIG_Py_Void();
5561 return resultobj;
5562 fail:
5563 return NULL;
5564 }
5565
5566
5567 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5568 PyObject *resultobj = 0;
5569 wxPoint *arg1 = (wxPoint *) 0 ;
5570 int result;
5571 void *argp1 = 0 ;
5572 int res1 = 0 ;
5573 PyObject *swig_obj[1] ;
5574
5575 if (!args) SWIG_fail;
5576 swig_obj[0] = args;
5577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5578 if (!SWIG_IsOK(res1)) {
5579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5580 }
5581 arg1 = reinterpret_cast< wxPoint * >(argp1);
5582 result = (int) ((arg1)->x);
5583 resultobj = SWIG_From_int(static_cast< int >(result));
5584 return resultobj;
5585 fail:
5586 return NULL;
5587 }
5588
5589
5590 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5591 PyObject *resultobj = 0;
5592 wxPoint *arg1 = (wxPoint *) 0 ;
5593 int arg2 ;
5594 void *argp1 = 0 ;
5595 int res1 = 0 ;
5596 int val2 ;
5597 int ecode2 = 0 ;
5598 PyObject *swig_obj[2] ;
5599
5600 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5602 if (!SWIG_IsOK(res1)) {
5603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5604 }
5605 arg1 = reinterpret_cast< wxPoint * >(argp1);
5606 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5607 if (!SWIG_IsOK(ecode2)) {
5608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5609 }
5610 arg2 = static_cast< int >(val2);
5611 if (arg1) (arg1)->y = arg2;
5612
5613 resultobj = SWIG_Py_Void();
5614 return resultobj;
5615 fail:
5616 return NULL;
5617 }
5618
5619
5620 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5621 PyObject *resultobj = 0;
5622 wxPoint *arg1 = (wxPoint *) 0 ;
5623 int result;
5624 void *argp1 = 0 ;
5625 int res1 = 0 ;
5626 PyObject *swig_obj[1] ;
5627
5628 if (!args) SWIG_fail;
5629 swig_obj[0] = args;
5630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5631 if (!SWIG_IsOK(res1)) {
5632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5633 }
5634 arg1 = reinterpret_cast< wxPoint * >(argp1);
5635 result = (int) ((arg1)->y);
5636 resultobj = SWIG_From_int(static_cast< int >(result));
5637 return resultobj;
5638 fail:
5639 return NULL;
5640 }
5641
5642
5643 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5644 PyObject *resultobj = 0;
5645 int arg1 = (int) 0 ;
5646 int arg2 = (int) 0 ;
5647 wxPoint *result = 0 ;
5648 int val1 ;
5649 int ecode1 = 0 ;
5650 int val2 ;
5651 int ecode2 = 0 ;
5652 PyObject * obj0 = 0 ;
5653 PyObject * obj1 = 0 ;
5654 char * kwnames[] = {
5655 (char *) "x",(char *) "y", NULL
5656 };
5657
5658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5659 if (obj0) {
5660 ecode1 = SWIG_AsVal_int(obj0, &val1);
5661 if (!SWIG_IsOK(ecode1)) {
5662 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5663 }
5664 arg1 = static_cast< int >(val1);
5665 }
5666 if (obj1) {
5667 ecode2 = SWIG_AsVal_int(obj1, &val2);
5668 if (!SWIG_IsOK(ecode2)) {
5669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5670 }
5671 arg2 = static_cast< int >(val2);
5672 }
5673 {
5674 PyThreadState* __tstate = wxPyBeginAllowThreads();
5675 result = (wxPoint *)new wxPoint(arg1,arg2);
5676 wxPyEndAllowThreads(__tstate);
5677 if (PyErr_Occurred()) SWIG_fail;
5678 }
5679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5680 return resultobj;
5681 fail:
5682 return NULL;
5683 }
5684
5685
5686 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5687 PyObject *resultobj = 0;
5688 wxPoint *arg1 = (wxPoint *) 0 ;
5689 void *argp1 = 0 ;
5690 int res1 = 0 ;
5691 PyObject *swig_obj[1] ;
5692
5693 if (!args) SWIG_fail;
5694 swig_obj[0] = args;
5695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5696 if (!SWIG_IsOK(res1)) {
5697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5698 }
5699 arg1 = reinterpret_cast< wxPoint * >(argp1);
5700 {
5701 PyThreadState* __tstate = wxPyBeginAllowThreads();
5702 delete arg1;
5703
5704 wxPyEndAllowThreads(__tstate);
5705 if (PyErr_Occurred()) SWIG_fail;
5706 }
5707 resultobj = SWIG_Py_Void();
5708 return resultobj;
5709 fail:
5710 return NULL;
5711 }
5712
5713
5714 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5715 PyObject *resultobj = 0;
5716 wxPoint *arg1 = (wxPoint *) 0 ;
5717 PyObject *arg2 = (PyObject *) 0 ;
5718 bool result;
5719 void *argp1 = 0 ;
5720 int res1 = 0 ;
5721 PyObject * obj0 = 0 ;
5722 PyObject * obj1 = 0 ;
5723 char * kwnames[] = {
5724 (char *) "self",(char *) "other", NULL
5725 };
5726
5727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5729 if (!SWIG_IsOK(res1)) {
5730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5731 }
5732 arg1 = reinterpret_cast< wxPoint * >(argp1);
5733 arg2 = obj1;
5734 {
5735 result = (bool)wxPoint___eq__(arg1,arg2);
5736 if (PyErr_Occurred()) SWIG_fail;
5737 }
5738 {
5739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5740 }
5741 return resultobj;
5742 fail:
5743 return NULL;
5744 }
5745
5746
5747 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5748 PyObject *resultobj = 0;
5749 wxPoint *arg1 = (wxPoint *) 0 ;
5750 PyObject *arg2 = (PyObject *) 0 ;
5751 bool result;
5752 void *argp1 = 0 ;
5753 int res1 = 0 ;
5754 PyObject * obj0 = 0 ;
5755 PyObject * obj1 = 0 ;
5756 char * kwnames[] = {
5757 (char *) "self",(char *) "other", NULL
5758 };
5759
5760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5762 if (!SWIG_IsOK(res1)) {
5763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5764 }
5765 arg1 = reinterpret_cast< wxPoint * >(argp1);
5766 arg2 = obj1;
5767 {
5768 result = (bool)wxPoint___ne__(arg1,arg2);
5769 if (PyErr_Occurred()) SWIG_fail;
5770 }
5771 {
5772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5773 }
5774 return resultobj;
5775 fail:
5776 return NULL;
5777 }
5778
5779
5780 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5781 PyObject *resultobj = 0;
5782 wxPoint *arg1 = (wxPoint *) 0 ;
5783 wxPoint *arg2 = 0 ;
5784 wxPoint result;
5785 void *argp1 = 0 ;
5786 int res1 = 0 ;
5787 wxPoint temp2 ;
5788 PyObject * obj0 = 0 ;
5789 PyObject * obj1 = 0 ;
5790 char * kwnames[] = {
5791 (char *) "self",(char *) "pt", NULL
5792 };
5793
5794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5796 if (!SWIG_IsOK(res1)) {
5797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5798 }
5799 arg1 = reinterpret_cast< wxPoint * >(argp1);
5800 {
5801 arg2 = &temp2;
5802 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5803 }
5804 {
5805 PyThreadState* __tstate = wxPyBeginAllowThreads();
5806 result = (arg1)->operator +((wxPoint const &)*arg2);
5807 wxPyEndAllowThreads(__tstate);
5808 if (PyErr_Occurred()) SWIG_fail;
5809 }
5810 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5811 return resultobj;
5812 fail:
5813 return NULL;
5814 }
5815
5816
5817 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5818 PyObject *resultobj = 0;
5819 wxPoint *arg1 = (wxPoint *) 0 ;
5820 wxPoint *arg2 = 0 ;
5821 wxPoint result;
5822 void *argp1 = 0 ;
5823 int res1 = 0 ;
5824 wxPoint temp2 ;
5825 PyObject * obj0 = 0 ;
5826 PyObject * obj1 = 0 ;
5827 char * kwnames[] = {
5828 (char *) "self",(char *) "pt", NULL
5829 };
5830
5831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5833 if (!SWIG_IsOK(res1)) {
5834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5835 }
5836 arg1 = reinterpret_cast< wxPoint * >(argp1);
5837 {
5838 arg2 = &temp2;
5839 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5840 }
5841 {
5842 PyThreadState* __tstate = wxPyBeginAllowThreads();
5843 result = (arg1)->operator -((wxPoint const &)*arg2);
5844 wxPyEndAllowThreads(__tstate);
5845 if (PyErr_Occurred()) SWIG_fail;
5846 }
5847 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5848 return resultobj;
5849 fail:
5850 return NULL;
5851 }
5852
5853
5854 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5855 PyObject *resultobj = 0;
5856 wxPoint *arg1 = (wxPoint *) 0 ;
5857 wxPoint *arg2 = 0 ;
5858 wxPoint *result = 0 ;
5859 void *argp1 = 0 ;
5860 int res1 = 0 ;
5861 wxPoint temp2 ;
5862 PyObject * obj0 = 0 ;
5863 PyObject * obj1 = 0 ;
5864 char * kwnames[] = {
5865 (char *) "self",(char *) "pt", NULL
5866 };
5867
5868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5870 if (!SWIG_IsOK(res1)) {
5871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5872 }
5873 arg1 = reinterpret_cast< wxPoint * >(argp1);
5874 {
5875 arg2 = &temp2;
5876 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5877 }
5878 {
5879 PyThreadState* __tstate = wxPyBeginAllowThreads();
5880 {
5881 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5882 result = (wxPoint *) &_result_ref;
5883 }
5884 wxPyEndAllowThreads(__tstate);
5885 if (PyErr_Occurred()) SWIG_fail;
5886 }
5887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5888 return resultobj;
5889 fail:
5890 return NULL;
5891 }
5892
5893
5894 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5895 PyObject *resultobj = 0;
5896 wxPoint *arg1 = (wxPoint *) 0 ;
5897 wxPoint *arg2 = 0 ;
5898 wxPoint *result = 0 ;
5899 void *argp1 = 0 ;
5900 int res1 = 0 ;
5901 wxPoint temp2 ;
5902 PyObject * obj0 = 0 ;
5903 PyObject * obj1 = 0 ;
5904 char * kwnames[] = {
5905 (char *) "self",(char *) "pt", NULL
5906 };
5907
5908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5910 if (!SWIG_IsOK(res1)) {
5911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5912 }
5913 arg1 = reinterpret_cast< wxPoint * >(argp1);
5914 {
5915 arg2 = &temp2;
5916 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5917 }
5918 {
5919 PyThreadState* __tstate = wxPyBeginAllowThreads();
5920 {
5921 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5922 result = (wxPoint *) &_result_ref;
5923 }
5924 wxPyEndAllowThreads(__tstate);
5925 if (PyErr_Occurred()) SWIG_fail;
5926 }
5927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5928 return resultobj;
5929 fail:
5930 return NULL;
5931 }
5932
5933
5934 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5935 PyObject *resultobj = 0;
5936 wxPoint *arg1 = (wxPoint *) 0 ;
5937 long arg2 ;
5938 long arg3 ;
5939 void *argp1 = 0 ;
5940 int res1 = 0 ;
5941 long val2 ;
5942 int ecode2 = 0 ;
5943 long val3 ;
5944 int ecode3 = 0 ;
5945 PyObject * obj0 = 0 ;
5946 PyObject * obj1 = 0 ;
5947 PyObject * obj2 = 0 ;
5948 char * kwnames[] = {
5949 (char *) "self",(char *) "x",(char *) "y", NULL
5950 };
5951
5952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5954 if (!SWIG_IsOK(res1)) {
5955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5956 }
5957 arg1 = reinterpret_cast< wxPoint * >(argp1);
5958 ecode2 = SWIG_AsVal_long(obj1, &val2);
5959 if (!SWIG_IsOK(ecode2)) {
5960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5961 }
5962 arg2 = static_cast< long >(val2);
5963 ecode3 = SWIG_AsVal_long(obj2, &val3);
5964 if (!SWIG_IsOK(ecode3)) {
5965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5966 }
5967 arg3 = static_cast< long >(val3);
5968 {
5969 PyThreadState* __tstate = wxPyBeginAllowThreads();
5970 wxPoint_Set(arg1,arg2,arg3);
5971 wxPyEndAllowThreads(__tstate);
5972 if (PyErr_Occurred()) SWIG_fail;
5973 }
5974 resultobj = SWIG_Py_Void();
5975 return resultobj;
5976 fail:
5977 return NULL;
5978 }
5979
5980
5981 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5982 PyObject *resultobj = 0;
5983 wxPoint *arg1 = (wxPoint *) 0 ;
5984 PyObject *result = 0 ;
5985 void *argp1 = 0 ;
5986 int res1 = 0 ;
5987 PyObject *swig_obj[1] ;
5988
5989 if (!args) SWIG_fail;
5990 swig_obj[0] = args;
5991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5992 if (!SWIG_IsOK(res1)) {
5993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5994 }
5995 arg1 = reinterpret_cast< wxPoint * >(argp1);
5996 {
5997 PyThreadState* __tstate = wxPyBeginAllowThreads();
5998 result = (PyObject *)wxPoint_Get(arg1);
5999 wxPyEndAllowThreads(__tstate);
6000 if (PyErr_Occurred()) SWIG_fail;
6001 }
6002 resultobj = result;
6003 return resultobj;
6004 fail:
6005 return NULL;
6006 }
6007
6008
6009 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6010 PyObject *obj;
6011 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6012 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6013 return SWIG_Py_Void();
6014 }
6015
6016 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6017 return SWIG_Python_InitShadowInstance(args);
6018 }
6019
6020 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6021 PyObject *resultobj = 0;
6022 int arg1 = (int) 0 ;
6023 int arg2 = (int) 0 ;
6024 int arg3 = (int) 0 ;
6025 int arg4 = (int) 0 ;
6026 wxRect *result = 0 ;
6027 int val1 ;
6028 int ecode1 = 0 ;
6029 int val2 ;
6030 int ecode2 = 0 ;
6031 int val3 ;
6032 int ecode3 = 0 ;
6033 int val4 ;
6034 int ecode4 = 0 ;
6035 PyObject * obj0 = 0 ;
6036 PyObject * obj1 = 0 ;
6037 PyObject * obj2 = 0 ;
6038 PyObject * obj3 = 0 ;
6039 char * kwnames[] = {
6040 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6041 };
6042
6043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6044 if (obj0) {
6045 ecode1 = SWIG_AsVal_int(obj0, &val1);
6046 if (!SWIG_IsOK(ecode1)) {
6047 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6048 }
6049 arg1 = static_cast< int >(val1);
6050 }
6051 if (obj1) {
6052 ecode2 = SWIG_AsVal_int(obj1, &val2);
6053 if (!SWIG_IsOK(ecode2)) {
6054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6055 }
6056 arg2 = static_cast< int >(val2);
6057 }
6058 if (obj2) {
6059 ecode3 = SWIG_AsVal_int(obj2, &val3);
6060 if (!SWIG_IsOK(ecode3)) {
6061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6062 }
6063 arg3 = static_cast< int >(val3);
6064 }
6065 if (obj3) {
6066 ecode4 = SWIG_AsVal_int(obj3, &val4);
6067 if (!SWIG_IsOK(ecode4)) {
6068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6069 }
6070 arg4 = static_cast< int >(val4);
6071 }
6072 {
6073 PyThreadState* __tstate = wxPyBeginAllowThreads();
6074 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6075 wxPyEndAllowThreads(__tstate);
6076 if (PyErr_Occurred()) SWIG_fail;
6077 }
6078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6079 return resultobj;
6080 fail:
6081 return NULL;
6082 }
6083
6084
6085 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6086 PyObject *resultobj = 0;
6087 wxPoint *arg1 = 0 ;
6088 wxPoint *arg2 = 0 ;
6089 wxRect *result = 0 ;
6090 wxPoint temp1 ;
6091 wxPoint temp2 ;
6092 PyObject * obj0 = 0 ;
6093 PyObject * obj1 = 0 ;
6094 char * kwnames[] = {
6095 (char *) "topLeft",(char *) "bottomRight", NULL
6096 };
6097
6098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6099 {
6100 arg1 = &temp1;
6101 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6102 }
6103 {
6104 arg2 = &temp2;
6105 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6106 }
6107 {
6108 PyThreadState* __tstate = wxPyBeginAllowThreads();
6109 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6110 wxPyEndAllowThreads(__tstate);
6111 if (PyErr_Occurred()) SWIG_fail;
6112 }
6113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6114 return resultobj;
6115 fail:
6116 return NULL;
6117 }
6118
6119
6120 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6121 PyObject *resultobj = 0;
6122 wxPoint *arg1 = 0 ;
6123 wxSize *arg2 = 0 ;
6124 wxRect *result = 0 ;
6125 wxPoint temp1 ;
6126 wxSize temp2 ;
6127 PyObject * obj0 = 0 ;
6128 PyObject * obj1 = 0 ;
6129 char * kwnames[] = {
6130 (char *) "pos",(char *) "size", NULL
6131 };
6132
6133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6134 {
6135 arg1 = &temp1;
6136 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6137 }
6138 {
6139 arg2 = &temp2;
6140 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6141 }
6142 {
6143 PyThreadState* __tstate = wxPyBeginAllowThreads();
6144 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6145 wxPyEndAllowThreads(__tstate);
6146 if (PyErr_Occurred()) SWIG_fail;
6147 }
6148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6149 return resultobj;
6150 fail:
6151 return NULL;
6152 }
6153
6154
6155 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6156 PyObject *resultobj = 0;
6157 wxSize *arg1 = 0 ;
6158 wxRect *result = 0 ;
6159 wxSize temp1 ;
6160 PyObject * obj0 = 0 ;
6161 char * kwnames[] = {
6162 (char *) "size", NULL
6163 };
6164
6165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6166 {
6167 arg1 = &temp1;
6168 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6169 }
6170 {
6171 PyThreadState* __tstate = wxPyBeginAllowThreads();
6172 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6173 wxPyEndAllowThreads(__tstate);
6174 if (PyErr_Occurred()) SWIG_fail;
6175 }
6176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6177 return resultobj;
6178 fail:
6179 return NULL;
6180 }
6181
6182
6183 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6184 PyObject *resultobj = 0;
6185 wxRect *arg1 = (wxRect *) 0 ;
6186 void *argp1 = 0 ;
6187 int res1 = 0 ;
6188 PyObject *swig_obj[1] ;
6189
6190 if (!args) SWIG_fail;
6191 swig_obj[0] = args;
6192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6193 if (!SWIG_IsOK(res1)) {
6194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6195 }
6196 arg1 = reinterpret_cast< wxRect * >(argp1);
6197 {
6198 PyThreadState* __tstate = wxPyBeginAllowThreads();
6199 delete arg1;
6200
6201 wxPyEndAllowThreads(__tstate);
6202 if (PyErr_Occurred()) SWIG_fail;
6203 }
6204 resultobj = SWIG_Py_Void();
6205 return resultobj;
6206 fail:
6207 return NULL;
6208 }
6209
6210
6211 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6212 PyObject *resultobj = 0;
6213 wxRect *arg1 = (wxRect *) 0 ;
6214 int result;
6215 void *argp1 = 0 ;
6216 int res1 = 0 ;
6217 PyObject *swig_obj[1] ;
6218
6219 if (!args) SWIG_fail;
6220 swig_obj[0] = args;
6221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6222 if (!SWIG_IsOK(res1)) {
6223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6224 }
6225 arg1 = reinterpret_cast< wxRect * >(argp1);
6226 {
6227 PyThreadState* __tstate = wxPyBeginAllowThreads();
6228 result = (int)((wxRect const *)arg1)->GetX();
6229 wxPyEndAllowThreads(__tstate);
6230 if (PyErr_Occurred()) SWIG_fail;
6231 }
6232 resultobj = SWIG_From_int(static_cast< int >(result));
6233 return resultobj;
6234 fail:
6235 return NULL;
6236 }
6237
6238
6239 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6240 PyObject *resultobj = 0;
6241 wxRect *arg1 = (wxRect *) 0 ;
6242 int arg2 ;
6243 void *argp1 = 0 ;
6244 int res1 = 0 ;
6245 int val2 ;
6246 int ecode2 = 0 ;
6247 PyObject * obj0 = 0 ;
6248 PyObject * obj1 = 0 ;
6249 char * kwnames[] = {
6250 (char *) "self",(char *) "x", NULL
6251 };
6252
6253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6255 if (!SWIG_IsOK(res1)) {
6256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6257 }
6258 arg1 = reinterpret_cast< wxRect * >(argp1);
6259 ecode2 = SWIG_AsVal_int(obj1, &val2);
6260 if (!SWIG_IsOK(ecode2)) {
6261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6262 }
6263 arg2 = static_cast< int >(val2);
6264 {
6265 PyThreadState* __tstate = wxPyBeginAllowThreads();
6266 (arg1)->SetX(arg2);
6267 wxPyEndAllowThreads(__tstate);
6268 if (PyErr_Occurred()) SWIG_fail;
6269 }
6270 resultobj = SWIG_Py_Void();
6271 return resultobj;
6272 fail:
6273 return NULL;
6274 }
6275
6276
6277 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6278 PyObject *resultobj = 0;
6279 wxRect *arg1 = (wxRect *) 0 ;
6280 int result;
6281 void *argp1 = 0 ;
6282 int res1 = 0 ;
6283 PyObject *swig_obj[1] ;
6284
6285 if (!args) SWIG_fail;
6286 swig_obj[0] = args;
6287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6288 if (!SWIG_IsOK(res1)) {
6289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6290 }
6291 arg1 = reinterpret_cast< wxRect * >(argp1);
6292 {
6293 PyThreadState* __tstate = wxPyBeginAllowThreads();
6294 result = (int)(arg1)->GetY();
6295 wxPyEndAllowThreads(__tstate);
6296 if (PyErr_Occurred()) SWIG_fail;
6297 }
6298 resultobj = SWIG_From_int(static_cast< int >(result));
6299 return resultobj;
6300 fail:
6301 return NULL;
6302 }
6303
6304
6305 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6306 PyObject *resultobj = 0;
6307 wxRect *arg1 = (wxRect *) 0 ;
6308 int arg2 ;
6309 void *argp1 = 0 ;
6310 int res1 = 0 ;
6311 int val2 ;
6312 int ecode2 = 0 ;
6313 PyObject * obj0 = 0 ;
6314 PyObject * obj1 = 0 ;
6315 char * kwnames[] = {
6316 (char *) "self",(char *) "y", NULL
6317 };
6318
6319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6321 if (!SWIG_IsOK(res1)) {
6322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6323 }
6324 arg1 = reinterpret_cast< wxRect * >(argp1);
6325 ecode2 = SWIG_AsVal_int(obj1, &val2);
6326 if (!SWIG_IsOK(ecode2)) {
6327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6328 }
6329 arg2 = static_cast< int >(val2);
6330 {
6331 PyThreadState* __tstate = wxPyBeginAllowThreads();
6332 (arg1)->SetY(arg2);
6333 wxPyEndAllowThreads(__tstate);
6334 if (PyErr_Occurred()) SWIG_fail;
6335 }
6336 resultobj = SWIG_Py_Void();
6337 return resultobj;
6338 fail:
6339 return NULL;
6340 }
6341
6342
6343 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6344 PyObject *resultobj = 0;
6345 wxRect *arg1 = (wxRect *) 0 ;
6346 int result;
6347 void *argp1 = 0 ;
6348 int res1 = 0 ;
6349 PyObject *swig_obj[1] ;
6350
6351 if (!args) SWIG_fail;
6352 swig_obj[0] = args;
6353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6354 if (!SWIG_IsOK(res1)) {
6355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6356 }
6357 arg1 = reinterpret_cast< wxRect * >(argp1);
6358 {
6359 PyThreadState* __tstate = wxPyBeginAllowThreads();
6360 result = (int)((wxRect const *)arg1)->GetWidth();
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 resultobj = SWIG_From_int(static_cast< int >(result));
6365 return resultobj;
6366 fail:
6367 return NULL;
6368 }
6369
6370
6371 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6372 PyObject *resultobj = 0;
6373 wxRect *arg1 = (wxRect *) 0 ;
6374 int arg2 ;
6375 void *argp1 = 0 ;
6376 int res1 = 0 ;
6377 int val2 ;
6378 int ecode2 = 0 ;
6379 PyObject * obj0 = 0 ;
6380 PyObject * obj1 = 0 ;
6381 char * kwnames[] = {
6382 (char *) "self",(char *) "w", NULL
6383 };
6384
6385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6387 if (!SWIG_IsOK(res1)) {
6388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6389 }
6390 arg1 = reinterpret_cast< wxRect * >(argp1);
6391 ecode2 = SWIG_AsVal_int(obj1, &val2);
6392 if (!SWIG_IsOK(ecode2)) {
6393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6394 }
6395 arg2 = static_cast< int >(val2);
6396 {
6397 PyThreadState* __tstate = wxPyBeginAllowThreads();
6398 (arg1)->SetWidth(arg2);
6399 wxPyEndAllowThreads(__tstate);
6400 if (PyErr_Occurred()) SWIG_fail;
6401 }
6402 resultobj = SWIG_Py_Void();
6403 return resultobj;
6404 fail:
6405 return NULL;
6406 }
6407
6408
6409 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6410 PyObject *resultobj = 0;
6411 wxRect *arg1 = (wxRect *) 0 ;
6412 int result;
6413 void *argp1 = 0 ;
6414 int res1 = 0 ;
6415 PyObject *swig_obj[1] ;
6416
6417 if (!args) SWIG_fail;
6418 swig_obj[0] = args;
6419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6420 if (!SWIG_IsOK(res1)) {
6421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6422 }
6423 arg1 = reinterpret_cast< wxRect * >(argp1);
6424 {
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 result = (int)((wxRect const *)arg1)->GetHeight();
6427 wxPyEndAllowThreads(__tstate);
6428 if (PyErr_Occurred()) SWIG_fail;
6429 }
6430 resultobj = SWIG_From_int(static_cast< int >(result));
6431 return resultobj;
6432 fail:
6433 return NULL;
6434 }
6435
6436
6437 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6438 PyObject *resultobj = 0;
6439 wxRect *arg1 = (wxRect *) 0 ;
6440 int arg2 ;
6441 void *argp1 = 0 ;
6442 int res1 = 0 ;
6443 int val2 ;
6444 int ecode2 = 0 ;
6445 PyObject * obj0 = 0 ;
6446 PyObject * obj1 = 0 ;
6447 char * kwnames[] = {
6448 (char *) "self",(char *) "h", NULL
6449 };
6450
6451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6453 if (!SWIG_IsOK(res1)) {
6454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6455 }
6456 arg1 = reinterpret_cast< wxRect * >(argp1);
6457 ecode2 = SWIG_AsVal_int(obj1, &val2);
6458 if (!SWIG_IsOK(ecode2)) {
6459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6460 }
6461 arg2 = static_cast< int >(val2);
6462 {
6463 PyThreadState* __tstate = wxPyBeginAllowThreads();
6464 (arg1)->SetHeight(arg2);
6465 wxPyEndAllowThreads(__tstate);
6466 if (PyErr_Occurred()) SWIG_fail;
6467 }
6468 resultobj = SWIG_Py_Void();
6469 return resultobj;
6470 fail:
6471 return NULL;
6472 }
6473
6474
6475 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6476 PyObject *resultobj = 0;
6477 wxRect *arg1 = (wxRect *) 0 ;
6478 wxPoint result;
6479 void *argp1 = 0 ;
6480 int res1 = 0 ;
6481 PyObject *swig_obj[1] ;
6482
6483 if (!args) SWIG_fail;
6484 swig_obj[0] = args;
6485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6486 if (!SWIG_IsOK(res1)) {
6487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6488 }
6489 arg1 = reinterpret_cast< wxRect * >(argp1);
6490 {
6491 PyThreadState* __tstate = wxPyBeginAllowThreads();
6492 result = ((wxRect const *)arg1)->GetPosition();
6493 wxPyEndAllowThreads(__tstate);
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6497 return resultobj;
6498 fail:
6499 return NULL;
6500 }
6501
6502
6503 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6504 PyObject *resultobj = 0;
6505 wxRect *arg1 = (wxRect *) 0 ;
6506 wxPoint *arg2 = 0 ;
6507 void *argp1 = 0 ;
6508 int res1 = 0 ;
6509 wxPoint temp2 ;
6510 PyObject * obj0 = 0 ;
6511 PyObject * obj1 = 0 ;
6512 char * kwnames[] = {
6513 (char *) "self",(char *) "p", NULL
6514 };
6515
6516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6518 if (!SWIG_IsOK(res1)) {
6519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6520 }
6521 arg1 = reinterpret_cast< wxRect * >(argp1);
6522 {
6523 arg2 = &temp2;
6524 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6525 }
6526 {
6527 PyThreadState* __tstate = wxPyBeginAllowThreads();
6528 (arg1)->SetPosition((wxPoint const &)*arg2);
6529 wxPyEndAllowThreads(__tstate);
6530 if (PyErr_Occurred()) SWIG_fail;
6531 }
6532 resultobj = SWIG_Py_Void();
6533 return resultobj;
6534 fail:
6535 return NULL;
6536 }
6537
6538
6539 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6540 PyObject *resultobj = 0;
6541 wxRect *arg1 = (wxRect *) 0 ;
6542 wxSize result;
6543 void *argp1 = 0 ;
6544 int res1 = 0 ;
6545 PyObject *swig_obj[1] ;
6546
6547 if (!args) SWIG_fail;
6548 swig_obj[0] = args;
6549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6550 if (!SWIG_IsOK(res1)) {
6551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6552 }
6553 arg1 = reinterpret_cast< wxRect * >(argp1);
6554 {
6555 PyThreadState* __tstate = wxPyBeginAllowThreads();
6556 result = ((wxRect const *)arg1)->GetSize();
6557 wxPyEndAllowThreads(__tstate);
6558 if (PyErr_Occurred()) SWIG_fail;
6559 }
6560 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6561 return resultobj;
6562 fail:
6563 return NULL;
6564 }
6565
6566
6567 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6568 PyObject *resultobj = 0;
6569 wxRect *arg1 = (wxRect *) 0 ;
6570 wxSize *arg2 = 0 ;
6571 void *argp1 = 0 ;
6572 int res1 = 0 ;
6573 wxSize temp2 ;
6574 PyObject * obj0 = 0 ;
6575 PyObject * obj1 = 0 ;
6576 char * kwnames[] = {
6577 (char *) "self",(char *) "s", NULL
6578 };
6579
6580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6582 if (!SWIG_IsOK(res1)) {
6583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6584 }
6585 arg1 = reinterpret_cast< wxRect * >(argp1);
6586 {
6587 arg2 = &temp2;
6588 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6589 }
6590 {
6591 PyThreadState* __tstate = wxPyBeginAllowThreads();
6592 (arg1)->SetSize((wxSize const &)*arg2);
6593 wxPyEndAllowThreads(__tstate);
6594 if (PyErr_Occurred()) SWIG_fail;
6595 }
6596 resultobj = SWIG_Py_Void();
6597 return resultobj;
6598 fail:
6599 return NULL;
6600 }
6601
6602
6603 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6604 PyObject *resultobj = 0;
6605 wxRect *arg1 = (wxRect *) 0 ;
6606 bool result;
6607 void *argp1 = 0 ;
6608 int res1 = 0 ;
6609 PyObject *swig_obj[1] ;
6610
6611 if (!args) SWIG_fail;
6612 swig_obj[0] = args;
6613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6614 if (!SWIG_IsOK(res1)) {
6615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6616 }
6617 arg1 = reinterpret_cast< wxRect * >(argp1);
6618 {
6619 PyThreadState* __tstate = wxPyBeginAllowThreads();
6620 result = (bool)((wxRect const *)arg1)->IsEmpty();
6621 wxPyEndAllowThreads(__tstate);
6622 if (PyErr_Occurred()) SWIG_fail;
6623 }
6624 {
6625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6626 }
6627 return resultobj;
6628 fail:
6629 return NULL;
6630 }
6631
6632
6633 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6634 PyObject *resultobj = 0;
6635 wxRect *arg1 = (wxRect *) 0 ;
6636 wxPoint result;
6637 void *argp1 = 0 ;
6638 int res1 = 0 ;
6639 PyObject *swig_obj[1] ;
6640
6641 if (!args) SWIG_fail;
6642 swig_obj[0] = args;
6643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6644 if (!SWIG_IsOK(res1)) {
6645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6646 }
6647 arg1 = reinterpret_cast< wxRect * >(argp1);
6648 {
6649 PyThreadState* __tstate = wxPyBeginAllowThreads();
6650 result = ((wxRect const *)arg1)->GetTopLeft();
6651 wxPyEndAllowThreads(__tstate);
6652 if (PyErr_Occurred()) SWIG_fail;
6653 }
6654 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6655 return resultobj;
6656 fail:
6657 return NULL;
6658 }
6659
6660
6661 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6662 PyObject *resultobj = 0;
6663 wxRect *arg1 = (wxRect *) 0 ;
6664 wxPoint *arg2 = 0 ;
6665 void *argp1 = 0 ;
6666 int res1 = 0 ;
6667 wxPoint temp2 ;
6668 PyObject * obj0 = 0 ;
6669 PyObject * obj1 = 0 ;
6670 char * kwnames[] = {
6671 (char *) "self",(char *) "p", NULL
6672 };
6673
6674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6676 if (!SWIG_IsOK(res1)) {
6677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6678 }
6679 arg1 = reinterpret_cast< wxRect * >(argp1);
6680 {
6681 arg2 = &temp2;
6682 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6683 }
6684 {
6685 PyThreadState* __tstate = wxPyBeginAllowThreads();
6686 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6687 wxPyEndAllowThreads(__tstate);
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 resultobj = SWIG_Py_Void();
6691 return resultobj;
6692 fail:
6693 return NULL;
6694 }
6695
6696
6697 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6698 PyObject *resultobj = 0;
6699 wxRect *arg1 = (wxRect *) 0 ;
6700 wxPoint result;
6701 void *argp1 = 0 ;
6702 int res1 = 0 ;
6703 PyObject *swig_obj[1] ;
6704
6705 if (!args) SWIG_fail;
6706 swig_obj[0] = args;
6707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6708 if (!SWIG_IsOK(res1)) {
6709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6710 }
6711 arg1 = reinterpret_cast< wxRect * >(argp1);
6712 {
6713 PyThreadState* __tstate = wxPyBeginAllowThreads();
6714 result = ((wxRect const *)arg1)->GetBottomRight();
6715 wxPyEndAllowThreads(__tstate);
6716 if (PyErr_Occurred()) SWIG_fail;
6717 }
6718 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6719 return resultobj;
6720 fail:
6721 return NULL;
6722 }
6723
6724
6725 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6726 PyObject *resultobj = 0;
6727 wxRect *arg1 = (wxRect *) 0 ;
6728 wxPoint *arg2 = 0 ;
6729 void *argp1 = 0 ;
6730 int res1 = 0 ;
6731 wxPoint temp2 ;
6732 PyObject * obj0 = 0 ;
6733 PyObject * obj1 = 0 ;
6734 char * kwnames[] = {
6735 (char *) "self",(char *) "p", NULL
6736 };
6737
6738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6740 if (!SWIG_IsOK(res1)) {
6741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6742 }
6743 arg1 = reinterpret_cast< wxRect * >(argp1);
6744 {
6745 arg2 = &temp2;
6746 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6747 }
6748 {
6749 PyThreadState* __tstate = wxPyBeginAllowThreads();
6750 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6751 wxPyEndAllowThreads(__tstate);
6752 if (PyErr_Occurred()) SWIG_fail;
6753 }
6754 resultobj = SWIG_Py_Void();
6755 return resultobj;
6756 fail:
6757 return NULL;
6758 }
6759
6760
6761 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6762 PyObject *resultobj = 0;
6763 wxRect *arg1 = (wxRect *) 0 ;
6764 int result;
6765 void *argp1 = 0 ;
6766 int res1 = 0 ;
6767 PyObject *swig_obj[1] ;
6768
6769 if (!args) SWIG_fail;
6770 swig_obj[0] = args;
6771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6772 if (!SWIG_IsOK(res1)) {
6773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6774 }
6775 arg1 = reinterpret_cast< wxRect * >(argp1);
6776 {
6777 PyThreadState* __tstate = wxPyBeginAllowThreads();
6778 result = (int)((wxRect const *)arg1)->GetLeft();
6779 wxPyEndAllowThreads(__tstate);
6780 if (PyErr_Occurred()) SWIG_fail;
6781 }
6782 resultobj = SWIG_From_int(static_cast< int >(result));
6783 return resultobj;
6784 fail:
6785 return NULL;
6786 }
6787
6788
6789 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6790 PyObject *resultobj = 0;
6791 wxRect *arg1 = (wxRect *) 0 ;
6792 int result;
6793 void *argp1 = 0 ;
6794 int res1 = 0 ;
6795 PyObject *swig_obj[1] ;
6796
6797 if (!args) SWIG_fail;
6798 swig_obj[0] = args;
6799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6800 if (!SWIG_IsOK(res1)) {
6801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6802 }
6803 arg1 = reinterpret_cast< wxRect * >(argp1);
6804 {
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 result = (int)((wxRect const *)arg1)->GetTop();
6807 wxPyEndAllowThreads(__tstate);
6808 if (PyErr_Occurred()) SWIG_fail;
6809 }
6810 resultobj = SWIG_From_int(static_cast< int >(result));
6811 return resultobj;
6812 fail:
6813 return NULL;
6814 }
6815
6816
6817 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6818 PyObject *resultobj = 0;
6819 wxRect *arg1 = (wxRect *) 0 ;
6820 int result;
6821 void *argp1 = 0 ;
6822 int res1 = 0 ;
6823 PyObject *swig_obj[1] ;
6824
6825 if (!args) SWIG_fail;
6826 swig_obj[0] = args;
6827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6828 if (!SWIG_IsOK(res1)) {
6829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6830 }
6831 arg1 = reinterpret_cast< wxRect * >(argp1);
6832 {
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 result = (int)((wxRect const *)arg1)->GetBottom();
6835 wxPyEndAllowThreads(__tstate);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 resultobj = SWIG_From_int(static_cast< int >(result));
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6846 PyObject *resultobj = 0;
6847 wxRect *arg1 = (wxRect *) 0 ;
6848 int result;
6849 void *argp1 = 0 ;
6850 int res1 = 0 ;
6851 PyObject *swig_obj[1] ;
6852
6853 if (!args) SWIG_fail;
6854 swig_obj[0] = args;
6855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6856 if (!SWIG_IsOK(res1)) {
6857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6858 }
6859 arg1 = reinterpret_cast< wxRect * >(argp1);
6860 {
6861 PyThreadState* __tstate = wxPyBeginAllowThreads();
6862 result = (int)((wxRect const *)arg1)->GetRight();
6863 wxPyEndAllowThreads(__tstate);
6864 if (PyErr_Occurred()) SWIG_fail;
6865 }
6866 resultobj = SWIG_From_int(static_cast< int >(result));
6867 return resultobj;
6868 fail:
6869 return NULL;
6870 }
6871
6872
6873 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6874 PyObject *resultobj = 0;
6875 wxRect *arg1 = (wxRect *) 0 ;
6876 int arg2 ;
6877 void *argp1 = 0 ;
6878 int res1 = 0 ;
6879 int val2 ;
6880 int ecode2 = 0 ;
6881 PyObject * obj0 = 0 ;
6882 PyObject * obj1 = 0 ;
6883 char * kwnames[] = {
6884 (char *) "self",(char *) "left", NULL
6885 };
6886
6887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6889 if (!SWIG_IsOK(res1)) {
6890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6891 }
6892 arg1 = reinterpret_cast< wxRect * >(argp1);
6893 ecode2 = SWIG_AsVal_int(obj1, &val2);
6894 if (!SWIG_IsOK(ecode2)) {
6895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6896 }
6897 arg2 = static_cast< int >(val2);
6898 {
6899 PyThreadState* __tstate = wxPyBeginAllowThreads();
6900 (arg1)->SetLeft(arg2);
6901 wxPyEndAllowThreads(__tstate);
6902 if (PyErr_Occurred()) SWIG_fail;
6903 }
6904 resultobj = SWIG_Py_Void();
6905 return resultobj;
6906 fail:
6907 return NULL;
6908 }
6909
6910
6911 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6912 PyObject *resultobj = 0;
6913 wxRect *arg1 = (wxRect *) 0 ;
6914 int arg2 ;
6915 void *argp1 = 0 ;
6916 int res1 = 0 ;
6917 int val2 ;
6918 int ecode2 = 0 ;
6919 PyObject * obj0 = 0 ;
6920 PyObject * obj1 = 0 ;
6921 char * kwnames[] = {
6922 (char *) "self",(char *) "right", NULL
6923 };
6924
6925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6927 if (!SWIG_IsOK(res1)) {
6928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6929 }
6930 arg1 = reinterpret_cast< wxRect * >(argp1);
6931 ecode2 = SWIG_AsVal_int(obj1, &val2);
6932 if (!SWIG_IsOK(ecode2)) {
6933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6934 }
6935 arg2 = static_cast< int >(val2);
6936 {
6937 PyThreadState* __tstate = wxPyBeginAllowThreads();
6938 (arg1)->SetRight(arg2);
6939 wxPyEndAllowThreads(__tstate);
6940 if (PyErr_Occurred()) SWIG_fail;
6941 }
6942 resultobj = SWIG_Py_Void();
6943 return resultobj;
6944 fail:
6945 return NULL;
6946 }
6947
6948
6949 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6950 PyObject *resultobj = 0;
6951 wxRect *arg1 = (wxRect *) 0 ;
6952 int arg2 ;
6953 void *argp1 = 0 ;
6954 int res1 = 0 ;
6955 int val2 ;
6956 int ecode2 = 0 ;
6957 PyObject * obj0 = 0 ;
6958 PyObject * obj1 = 0 ;
6959 char * kwnames[] = {
6960 (char *) "self",(char *) "top", NULL
6961 };
6962
6963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6965 if (!SWIG_IsOK(res1)) {
6966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6967 }
6968 arg1 = reinterpret_cast< wxRect * >(argp1);
6969 ecode2 = SWIG_AsVal_int(obj1, &val2);
6970 if (!SWIG_IsOK(ecode2)) {
6971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6972 }
6973 arg2 = static_cast< int >(val2);
6974 {
6975 PyThreadState* __tstate = wxPyBeginAllowThreads();
6976 (arg1)->SetTop(arg2);
6977 wxPyEndAllowThreads(__tstate);
6978 if (PyErr_Occurred()) SWIG_fail;
6979 }
6980 resultobj = SWIG_Py_Void();
6981 return resultobj;
6982 fail:
6983 return NULL;
6984 }
6985
6986
6987 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6988 PyObject *resultobj = 0;
6989 wxRect *arg1 = (wxRect *) 0 ;
6990 int arg2 ;
6991 void *argp1 = 0 ;
6992 int res1 = 0 ;
6993 int val2 ;
6994 int ecode2 = 0 ;
6995 PyObject * obj0 = 0 ;
6996 PyObject * obj1 = 0 ;
6997 char * kwnames[] = {
6998 (char *) "self",(char *) "bottom", NULL
6999 };
7000
7001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7003 if (!SWIG_IsOK(res1)) {
7004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7005 }
7006 arg1 = reinterpret_cast< wxRect * >(argp1);
7007 ecode2 = SWIG_AsVal_int(obj1, &val2);
7008 if (!SWIG_IsOK(ecode2)) {
7009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7010 }
7011 arg2 = static_cast< int >(val2);
7012 {
7013 PyThreadState* __tstate = wxPyBeginAllowThreads();
7014 (arg1)->SetBottom(arg2);
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 resultobj = SWIG_Py_Void();
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7026 PyObject *resultobj = 0;
7027 wxRect *arg1 = (wxRect *) 0 ;
7028 int arg2 ;
7029 int arg3 ;
7030 wxRect *result = 0 ;
7031 void *argp1 = 0 ;
7032 int res1 = 0 ;
7033 int val2 ;
7034 int ecode2 = 0 ;
7035 int val3 ;
7036 int ecode3 = 0 ;
7037 PyObject * obj0 = 0 ;
7038 PyObject * obj1 = 0 ;
7039 PyObject * obj2 = 0 ;
7040 char * kwnames[] = {
7041 (char *) "self",(char *) "dx",(char *) "dy", NULL
7042 };
7043
7044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7046 if (!SWIG_IsOK(res1)) {
7047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7048 }
7049 arg1 = reinterpret_cast< wxRect * >(argp1);
7050 ecode2 = SWIG_AsVal_int(obj1, &val2);
7051 if (!SWIG_IsOK(ecode2)) {
7052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7053 }
7054 arg2 = static_cast< int >(val2);
7055 ecode3 = SWIG_AsVal_int(obj2, &val3);
7056 if (!SWIG_IsOK(ecode3)) {
7057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7058 }
7059 arg3 = static_cast< int >(val3);
7060 {
7061 PyThreadState* __tstate = wxPyBeginAllowThreads();
7062 {
7063 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7064 result = (wxRect *) &_result_ref;
7065 }
7066 wxPyEndAllowThreads(__tstate);
7067 if (PyErr_Occurred()) SWIG_fail;
7068 }
7069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7070 return resultobj;
7071 fail:
7072 return NULL;
7073 }
7074
7075
7076 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7077 PyObject *resultobj = 0;
7078 wxRect *arg1 = (wxRect *) 0 ;
7079 int arg2 ;
7080 int arg3 ;
7081 wxRect *result = 0 ;
7082 void *argp1 = 0 ;
7083 int res1 = 0 ;
7084 int val2 ;
7085 int ecode2 = 0 ;
7086 int val3 ;
7087 int ecode3 = 0 ;
7088 PyObject * obj0 = 0 ;
7089 PyObject * obj1 = 0 ;
7090 PyObject * obj2 = 0 ;
7091 char * kwnames[] = {
7092 (char *) "self",(char *) "dx",(char *) "dy", NULL
7093 };
7094
7095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7097 if (!SWIG_IsOK(res1)) {
7098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7099 }
7100 arg1 = reinterpret_cast< wxRect * >(argp1);
7101 ecode2 = SWIG_AsVal_int(obj1, &val2);
7102 if (!SWIG_IsOK(ecode2)) {
7103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7104 }
7105 arg2 = static_cast< int >(val2);
7106 ecode3 = SWIG_AsVal_int(obj2, &val3);
7107 if (!SWIG_IsOK(ecode3)) {
7108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7109 }
7110 arg3 = static_cast< int >(val3);
7111 {
7112 PyThreadState* __tstate = wxPyBeginAllowThreads();
7113 {
7114 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7115 result = (wxRect *) &_result_ref;
7116 }
7117 wxPyEndAllowThreads(__tstate);
7118 if (PyErr_Occurred()) SWIG_fail;
7119 }
7120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7121 return resultobj;
7122 fail:
7123 return NULL;
7124 }
7125
7126
7127 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7128 PyObject *resultobj = 0;
7129 wxRect *arg1 = (wxRect *) 0 ;
7130 int arg2 ;
7131 int arg3 ;
7132 void *argp1 = 0 ;
7133 int res1 = 0 ;
7134 int val2 ;
7135 int ecode2 = 0 ;
7136 int val3 ;
7137 int ecode3 = 0 ;
7138 PyObject * obj0 = 0 ;
7139 PyObject * obj1 = 0 ;
7140 PyObject * obj2 = 0 ;
7141 char * kwnames[] = {
7142 (char *) "self",(char *) "dx",(char *) "dy", NULL
7143 };
7144
7145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7147 if (!SWIG_IsOK(res1)) {
7148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7149 }
7150 arg1 = reinterpret_cast< wxRect * >(argp1);
7151 ecode2 = SWIG_AsVal_int(obj1, &val2);
7152 if (!SWIG_IsOK(ecode2)) {
7153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7154 }
7155 arg2 = static_cast< int >(val2);
7156 ecode3 = SWIG_AsVal_int(obj2, &val3);
7157 if (!SWIG_IsOK(ecode3)) {
7158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7159 }
7160 arg3 = static_cast< int >(val3);
7161 {
7162 PyThreadState* __tstate = wxPyBeginAllowThreads();
7163 (arg1)->Offset(arg2,arg3);
7164 wxPyEndAllowThreads(__tstate);
7165 if (PyErr_Occurred()) SWIG_fail;
7166 }
7167 resultobj = SWIG_Py_Void();
7168 return resultobj;
7169 fail:
7170 return NULL;
7171 }
7172
7173
7174 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7175 PyObject *resultobj = 0;
7176 wxRect *arg1 = (wxRect *) 0 ;
7177 wxPoint *arg2 = 0 ;
7178 void *argp1 = 0 ;
7179 int res1 = 0 ;
7180 wxPoint temp2 ;
7181 PyObject * obj0 = 0 ;
7182 PyObject * obj1 = 0 ;
7183 char * kwnames[] = {
7184 (char *) "self",(char *) "pt", NULL
7185 };
7186
7187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7189 if (!SWIG_IsOK(res1)) {
7190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7191 }
7192 arg1 = reinterpret_cast< wxRect * >(argp1);
7193 {
7194 arg2 = &temp2;
7195 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7196 }
7197 {
7198 PyThreadState* __tstate = wxPyBeginAllowThreads();
7199 (arg1)->Offset((wxPoint const &)*arg2);
7200 wxPyEndAllowThreads(__tstate);
7201 if (PyErr_Occurred()) SWIG_fail;
7202 }
7203 resultobj = SWIG_Py_Void();
7204 return resultobj;
7205 fail:
7206 return NULL;
7207 }
7208
7209
7210 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7211 PyObject *resultobj = 0;
7212 wxRect *arg1 = (wxRect *) 0 ;
7213 wxRect *arg2 = 0 ;
7214 wxRect result;
7215 void *argp1 = 0 ;
7216 int res1 = 0 ;
7217 wxRect temp2 ;
7218 PyObject * obj0 = 0 ;
7219 PyObject * obj1 = 0 ;
7220 char * kwnames[] = {
7221 (char *) "self",(char *) "rect", NULL
7222 };
7223
7224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7226 if (!SWIG_IsOK(res1)) {
7227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7228 }
7229 arg1 = reinterpret_cast< wxRect * >(argp1);
7230 {
7231 arg2 = &temp2;
7232 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7233 }
7234 {
7235 PyThreadState* __tstate = wxPyBeginAllowThreads();
7236 result = (arg1)->Intersect((wxRect const &)*arg2);
7237 wxPyEndAllowThreads(__tstate);
7238 if (PyErr_Occurred()) SWIG_fail;
7239 }
7240 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7241 return resultobj;
7242 fail:
7243 return NULL;
7244 }
7245
7246
7247 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7248 PyObject *resultobj = 0;
7249 wxRect *arg1 = (wxRect *) 0 ;
7250 wxRect *arg2 = 0 ;
7251 wxRect result;
7252 void *argp1 = 0 ;
7253 int res1 = 0 ;
7254 wxRect temp2 ;
7255 PyObject * obj0 = 0 ;
7256 PyObject * obj1 = 0 ;
7257 char * kwnames[] = {
7258 (char *) "self",(char *) "rect", NULL
7259 };
7260
7261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7263 if (!SWIG_IsOK(res1)) {
7264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7265 }
7266 arg1 = reinterpret_cast< wxRect * >(argp1);
7267 {
7268 arg2 = &temp2;
7269 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7270 }
7271 {
7272 PyThreadState* __tstate = wxPyBeginAllowThreads();
7273 result = (arg1)->Union((wxRect const &)*arg2);
7274 wxPyEndAllowThreads(__tstate);
7275 if (PyErr_Occurred()) SWIG_fail;
7276 }
7277 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7278 return resultobj;
7279 fail:
7280 return NULL;
7281 }
7282
7283
7284 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7285 PyObject *resultobj = 0;
7286 wxRect *arg1 = (wxRect *) 0 ;
7287 wxRect *arg2 = 0 ;
7288 wxRect result;
7289 void *argp1 = 0 ;
7290 int res1 = 0 ;
7291 wxRect temp2 ;
7292 PyObject * obj0 = 0 ;
7293 PyObject * obj1 = 0 ;
7294 char * kwnames[] = {
7295 (char *) "self",(char *) "rect", NULL
7296 };
7297
7298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7300 if (!SWIG_IsOK(res1)) {
7301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7302 }
7303 arg1 = reinterpret_cast< wxRect * >(argp1);
7304 {
7305 arg2 = &temp2;
7306 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7307 }
7308 {
7309 PyThreadState* __tstate = wxPyBeginAllowThreads();
7310 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7311 wxPyEndAllowThreads(__tstate);
7312 if (PyErr_Occurred()) SWIG_fail;
7313 }
7314 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7315 return resultobj;
7316 fail:
7317 return NULL;
7318 }
7319
7320
7321 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7322 PyObject *resultobj = 0;
7323 wxRect *arg1 = (wxRect *) 0 ;
7324 wxRect *arg2 = 0 ;
7325 wxRect *result = 0 ;
7326 void *argp1 = 0 ;
7327 int res1 = 0 ;
7328 wxRect temp2 ;
7329 PyObject * obj0 = 0 ;
7330 PyObject * obj1 = 0 ;
7331 char * kwnames[] = {
7332 (char *) "self",(char *) "rect", NULL
7333 };
7334
7335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7337 if (!SWIG_IsOK(res1)) {
7338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7339 }
7340 arg1 = reinterpret_cast< wxRect * >(argp1);
7341 {
7342 arg2 = &temp2;
7343 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7344 }
7345 {
7346 PyThreadState* __tstate = wxPyBeginAllowThreads();
7347 {
7348 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7349 result = (wxRect *) &_result_ref;
7350 }
7351 wxPyEndAllowThreads(__tstate);
7352 if (PyErr_Occurred()) SWIG_fail;
7353 }
7354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7355 return resultobj;
7356 fail:
7357 return NULL;
7358 }
7359
7360
7361 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7362 PyObject *resultobj = 0;
7363 wxRect *arg1 = (wxRect *) 0 ;
7364 PyObject *arg2 = (PyObject *) 0 ;
7365 bool result;
7366 void *argp1 = 0 ;
7367 int res1 = 0 ;
7368 PyObject * obj0 = 0 ;
7369 PyObject * obj1 = 0 ;
7370 char * kwnames[] = {
7371 (char *) "self",(char *) "other", NULL
7372 };
7373
7374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7376 if (!SWIG_IsOK(res1)) {
7377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7378 }
7379 arg1 = reinterpret_cast< wxRect * >(argp1);
7380 arg2 = obj1;
7381 {
7382 result = (bool)wxRect___eq__(arg1,arg2);
7383 if (PyErr_Occurred()) SWIG_fail;
7384 }
7385 {
7386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7387 }
7388 return resultobj;
7389 fail:
7390 return NULL;
7391 }
7392
7393
7394 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7395 PyObject *resultobj = 0;
7396 wxRect *arg1 = (wxRect *) 0 ;
7397 PyObject *arg2 = (PyObject *) 0 ;
7398 bool result;
7399 void *argp1 = 0 ;
7400 int res1 = 0 ;
7401 PyObject * obj0 = 0 ;
7402 PyObject * obj1 = 0 ;
7403 char * kwnames[] = {
7404 (char *) "self",(char *) "other", NULL
7405 };
7406
7407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7409 if (!SWIG_IsOK(res1)) {
7410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7411 }
7412 arg1 = reinterpret_cast< wxRect * >(argp1);
7413 arg2 = obj1;
7414 {
7415 result = (bool)wxRect___ne__(arg1,arg2);
7416 if (PyErr_Occurred()) SWIG_fail;
7417 }
7418 {
7419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7420 }
7421 return resultobj;
7422 fail:
7423 return NULL;
7424 }
7425
7426
7427 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7428 PyObject *resultobj = 0;
7429 wxRect *arg1 = (wxRect *) 0 ;
7430 int arg2 ;
7431 int arg3 ;
7432 bool result;
7433 void *argp1 = 0 ;
7434 int res1 = 0 ;
7435 int val2 ;
7436 int ecode2 = 0 ;
7437 int val3 ;
7438 int ecode3 = 0 ;
7439 PyObject * obj0 = 0 ;
7440 PyObject * obj1 = 0 ;
7441 PyObject * obj2 = 0 ;
7442 char * kwnames[] = {
7443 (char *) "self",(char *) "x",(char *) "y", NULL
7444 };
7445
7446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7448 if (!SWIG_IsOK(res1)) {
7449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7450 }
7451 arg1 = reinterpret_cast< wxRect * >(argp1);
7452 ecode2 = SWIG_AsVal_int(obj1, &val2);
7453 if (!SWIG_IsOK(ecode2)) {
7454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7455 }
7456 arg2 = static_cast< int >(val2);
7457 ecode3 = SWIG_AsVal_int(obj2, &val3);
7458 if (!SWIG_IsOK(ecode3)) {
7459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7460 }
7461 arg3 = static_cast< int >(val3);
7462 {
7463 PyThreadState* __tstate = wxPyBeginAllowThreads();
7464 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7465 wxPyEndAllowThreads(__tstate);
7466 if (PyErr_Occurred()) SWIG_fail;
7467 }
7468 {
7469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7470 }
7471 return resultobj;
7472 fail:
7473 return NULL;
7474 }
7475
7476
7477 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7478 PyObject *resultobj = 0;
7479 wxRect *arg1 = (wxRect *) 0 ;
7480 wxPoint *arg2 = 0 ;
7481 bool result;
7482 void *argp1 = 0 ;
7483 int res1 = 0 ;
7484 wxPoint temp2 ;
7485 PyObject * obj0 = 0 ;
7486 PyObject * obj1 = 0 ;
7487 char * kwnames[] = {
7488 (char *) "self",(char *) "pt", NULL
7489 };
7490
7491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7493 if (!SWIG_IsOK(res1)) {
7494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7495 }
7496 arg1 = reinterpret_cast< wxRect * >(argp1);
7497 {
7498 arg2 = &temp2;
7499 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7500 }
7501 {
7502 PyThreadState* __tstate = wxPyBeginAllowThreads();
7503 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7504 wxPyEndAllowThreads(__tstate);
7505 if (PyErr_Occurred()) SWIG_fail;
7506 }
7507 {
7508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7509 }
7510 return resultobj;
7511 fail:
7512 return NULL;
7513 }
7514
7515
7516 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7517 PyObject *resultobj = 0;
7518 wxRect *arg1 = (wxRect *) 0 ;
7519 wxRect *arg2 = 0 ;
7520 bool result;
7521 void *argp1 = 0 ;
7522 int res1 = 0 ;
7523 wxRect temp2 ;
7524 PyObject * obj0 = 0 ;
7525 PyObject * obj1 = 0 ;
7526 char * kwnames[] = {
7527 (char *) "self",(char *) "rect", NULL
7528 };
7529
7530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7532 if (!SWIG_IsOK(res1)) {
7533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7534 }
7535 arg1 = reinterpret_cast< wxRect * >(argp1);
7536 {
7537 arg2 = &temp2;
7538 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7539 }
7540 {
7541 PyThreadState* __tstate = wxPyBeginAllowThreads();
7542 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7543 wxPyEndAllowThreads(__tstate);
7544 if (PyErr_Occurred()) SWIG_fail;
7545 }
7546 {
7547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7548 }
7549 return resultobj;
7550 fail:
7551 return NULL;
7552 }
7553
7554
7555 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7556 PyObject *resultobj = 0;
7557 wxRect *arg1 = (wxRect *) 0 ;
7558 wxRect *arg2 = 0 ;
7559 int arg3 = (int) wxBOTH ;
7560 wxRect result;
7561 void *argp1 = 0 ;
7562 int res1 = 0 ;
7563 wxRect temp2 ;
7564 int val3 ;
7565 int ecode3 = 0 ;
7566 PyObject * obj0 = 0 ;
7567 PyObject * obj1 = 0 ;
7568 PyObject * obj2 = 0 ;
7569 char * kwnames[] = {
7570 (char *) "self",(char *) "r",(char *) "dir", NULL
7571 };
7572
7573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7575 if (!SWIG_IsOK(res1)) {
7576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7577 }
7578 arg1 = reinterpret_cast< wxRect * >(argp1);
7579 {
7580 arg2 = &temp2;
7581 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7582 }
7583 if (obj2) {
7584 ecode3 = SWIG_AsVal_int(obj2, &val3);
7585 if (!SWIG_IsOK(ecode3)) {
7586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7587 }
7588 arg3 = static_cast< int >(val3);
7589 }
7590 {
7591 PyThreadState* __tstate = wxPyBeginAllowThreads();
7592 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7593 wxPyEndAllowThreads(__tstate);
7594 if (PyErr_Occurred()) SWIG_fail;
7595 }
7596 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7597 return resultobj;
7598 fail:
7599 return NULL;
7600 }
7601
7602
7603 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7604 PyObject *resultobj = 0;
7605 wxRect *arg1 = (wxRect *) 0 ;
7606 int arg2 ;
7607 void *argp1 = 0 ;
7608 int res1 = 0 ;
7609 int val2 ;
7610 int ecode2 = 0 ;
7611 PyObject *swig_obj[2] ;
7612
7613 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7615 if (!SWIG_IsOK(res1)) {
7616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7617 }
7618 arg1 = reinterpret_cast< wxRect * >(argp1);
7619 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7620 if (!SWIG_IsOK(ecode2)) {
7621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7622 }
7623 arg2 = static_cast< int >(val2);
7624 if (arg1) (arg1)->x = arg2;
7625
7626 resultobj = SWIG_Py_Void();
7627 return resultobj;
7628 fail:
7629 return NULL;
7630 }
7631
7632
7633 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7634 PyObject *resultobj = 0;
7635 wxRect *arg1 = (wxRect *) 0 ;
7636 int result;
7637 void *argp1 = 0 ;
7638 int res1 = 0 ;
7639 PyObject *swig_obj[1] ;
7640
7641 if (!args) SWIG_fail;
7642 swig_obj[0] = args;
7643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7644 if (!SWIG_IsOK(res1)) {
7645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7646 }
7647 arg1 = reinterpret_cast< wxRect * >(argp1);
7648 result = (int) ((arg1)->x);
7649 resultobj = SWIG_From_int(static_cast< int >(result));
7650 return resultobj;
7651 fail:
7652 return NULL;
7653 }
7654
7655
7656 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7657 PyObject *resultobj = 0;
7658 wxRect *arg1 = (wxRect *) 0 ;
7659 int arg2 ;
7660 void *argp1 = 0 ;
7661 int res1 = 0 ;
7662 int val2 ;
7663 int ecode2 = 0 ;
7664 PyObject *swig_obj[2] ;
7665
7666 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7668 if (!SWIG_IsOK(res1)) {
7669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7670 }
7671 arg1 = reinterpret_cast< wxRect * >(argp1);
7672 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7673 if (!SWIG_IsOK(ecode2)) {
7674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7675 }
7676 arg2 = static_cast< int >(val2);
7677 if (arg1) (arg1)->y = arg2;
7678
7679 resultobj = SWIG_Py_Void();
7680 return resultobj;
7681 fail:
7682 return NULL;
7683 }
7684
7685
7686 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7687 PyObject *resultobj = 0;
7688 wxRect *arg1 = (wxRect *) 0 ;
7689 int result;
7690 void *argp1 = 0 ;
7691 int res1 = 0 ;
7692 PyObject *swig_obj[1] ;
7693
7694 if (!args) SWIG_fail;
7695 swig_obj[0] = args;
7696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7697 if (!SWIG_IsOK(res1)) {
7698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7699 }
7700 arg1 = reinterpret_cast< wxRect * >(argp1);
7701 result = (int) ((arg1)->y);
7702 resultobj = SWIG_From_int(static_cast< int >(result));
7703 return resultobj;
7704 fail:
7705 return NULL;
7706 }
7707
7708
7709 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7710 PyObject *resultobj = 0;
7711 wxRect *arg1 = (wxRect *) 0 ;
7712 int arg2 ;
7713 void *argp1 = 0 ;
7714 int res1 = 0 ;
7715 int val2 ;
7716 int ecode2 = 0 ;
7717 PyObject *swig_obj[2] ;
7718
7719 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7723 }
7724 arg1 = reinterpret_cast< wxRect * >(argp1);
7725 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7726 if (!SWIG_IsOK(ecode2)) {
7727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7728 }
7729 arg2 = static_cast< int >(val2);
7730 if (arg1) (arg1)->width = arg2;
7731
7732 resultobj = SWIG_Py_Void();
7733 return resultobj;
7734 fail:
7735 return NULL;
7736 }
7737
7738
7739 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7740 PyObject *resultobj = 0;
7741 wxRect *arg1 = (wxRect *) 0 ;
7742 int result;
7743 void *argp1 = 0 ;
7744 int res1 = 0 ;
7745 PyObject *swig_obj[1] ;
7746
7747 if (!args) SWIG_fail;
7748 swig_obj[0] = args;
7749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7750 if (!SWIG_IsOK(res1)) {
7751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7752 }
7753 arg1 = reinterpret_cast< wxRect * >(argp1);
7754 result = (int) ((arg1)->width);
7755 resultobj = SWIG_From_int(static_cast< int >(result));
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7763 PyObject *resultobj = 0;
7764 wxRect *arg1 = (wxRect *) 0 ;
7765 int arg2 ;
7766 void *argp1 = 0 ;
7767 int res1 = 0 ;
7768 int val2 ;
7769 int ecode2 = 0 ;
7770 PyObject *swig_obj[2] ;
7771
7772 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7774 if (!SWIG_IsOK(res1)) {
7775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7776 }
7777 arg1 = reinterpret_cast< wxRect * >(argp1);
7778 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7779 if (!SWIG_IsOK(ecode2)) {
7780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7781 }
7782 arg2 = static_cast< int >(val2);
7783 if (arg1) (arg1)->height = arg2;
7784
7785 resultobj = SWIG_Py_Void();
7786 return resultobj;
7787 fail:
7788 return NULL;
7789 }
7790
7791
7792 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7793 PyObject *resultobj = 0;
7794 wxRect *arg1 = (wxRect *) 0 ;
7795 int result;
7796 void *argp1 = 0 ;
7797 int res1 = 0 ;
7798 PyObject *swig_obj[1] ;
7799
7800 if (!args) SWIG_fail;
7801 swig_obj[0] = args;
7802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7803 if (!SWIG_IsOK(res1)) {
7804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7805 }
7806 arg1 = reinterpret_cast< wxRect * >(argp1);
7807 result = (int) ((arg1)->height);
7808 resultobj = SWIG_From_int(static_cast< int >(result));
7809 return resultobj;
7810 fail:
7811 return NULL;
7812 }
7813
7814
7815 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7816 PyObject *resultobj = 0;
7817 wxRect *arg1 = (wxRect *) 0 ;
7818 int arg2 = (int) 0 ;
7819 int arg3 = (int) 0 ;
7820 int arg4 = (int) 0 ;
7821 int arg5 = (int) 0 ;
7822 void *argp1 = 0 ;
7823 int res1 = 0 ;
7824 int val2 ;
7825 int ecode2 = 0 ;
7826 int val3 ;
7827 int ecode3 = 0 ;
7828 int val4 ;
7829 int ecode4 = 0 ;
7830 int val5 ;
7831 int ecode5 = 0 ;
7832 PyObject * obj0 = 0 ;
7833 PyObject * obj1 = 0 ;
7834 PyObject * obj2 = 0 ;
7835 PyObject * obj3 = 0 ;
7836 PyObject * obj4 = 0 ;
7837 char * kwnames[] = {
7838 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7839 };
7840
7841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7843 if (!SWIG_IsOK(res1)) {
7844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7845 }
7846 arg1 = reinterpret_cast< wxRect * >(argp1);
7847 if (obj1) {
7848 ecode2 = SWIG_AsVal_int(obj1, &val2);
7849 if (!SWIG_IsOK(ecode2)) {
7850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7851 }
7852 arg2 = static_cast< int >(val2);
7853 }
7854 if (obj2) {
7855 ecode3 = SWIG_AsVal_int(obj2, &val3);
7856 if (!SWIG_IsOK(ecode3)) {
7857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7858 }
7859 arg3 = static_cast< int >(val3);
7860 }
7861 if (obj3) {
7862 ecode4 = SWIG_AsVal_int(obj3, &val4);
7863 if (!SWIG_IsOK(ecode4)) {
7864 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7865 }
7866 arg4 = static_cast< int >(val4);
7867 }
7868 if (obj4) {
7869 ecode5 = SWIG_AsVal_int(obj4, &val5);
7870 if (!SWIG_IsOK(ecode5)) {
7871 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7872 }
7873 arg5 = static_cast< int >(val5);
7874 }
7875 {
7876 PyThreadState* __tstate = wxPyBeginAllowThreads();
7877 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7878 wxPyEndAllowThreads(__tstate);
7879 if (PyErr_Occurred()) SWIG_fail;
7880 }
7881 resultobj = SWIG_Py_Void();
7882 return resultobj;
7883 fail:
7884 return NULL;
7885 }
7886
7887
7888 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7889 PyObject *resultobj = 0;
7890 wxRect *arg1 = (wxRect *) 0 ;
7891 PyObject *result = 0 ;
7892 void *argp1 = 0 ;
7893 int res1 = 0 ;
7894 PyObject *swig_obj[1] ;
7895
7896 if (!args) SWIG_fail;
7897 swig_obj[0] = args;
7898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7899 if (!SWIG_IsOK(res1)) {
7900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7901 }
7902 arg1 = reinterpret_cast< wxRect * >(argp1);
7903 {
7904 PyThreadState* __tstate = wxPyBeginAllowThreads();
7905 result = (PyObject *)wxRect_Get(arg1);
7906 wxPyEndAllowThreads(__tstate);
7907 if (PyErr_Occurred()) SWIG_fail;
7908 }
7909 resultobj = result;
7910 return resultobj;
7911 fail:
7912 return NULL;
7913 }
7914
7915
7916 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7917 PyObject *obj;
7918 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7919 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7920 return SWIG_Py_Void();
7921 }
7922
7923 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7924 return SWIG_Python_InitShadowInstance(args);
7925 }
7926
7927 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7928 PyObject *resultobj = 0;
7929 wxRect *arg1 = (wxRect *) 0 ;
7930 wxRect *arg2 = (wxRect *) 0 ;
7931 PyObject *result = 0 ;
7932 void *argp1 = 0 ;
7933 int res1 = 0 ;
7934 void *argp2 = 0 ;
7935 int res2 = 0 ;
7936 PyObject * obj0 = 0 ;
7937 PyObject * obj1 = 0 ;
7938 char * kwnames[] = {
7939 (char *) "r1",(char *) "r2", NULL
7940 };
7941
7942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7944 if (!SWIG_IsOK(res1)) {
7945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7946 }
7947 arg1 = reinterpret_cast< wxRect * >(argp1);
7948 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7949 if (!SWIG_IsOK(res2)) {
7950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7951 }
7952 arg2 = reinterpret_cast< wxRect * >(argp2);
7953 {
7954 if (!wxPyCheckForApp()) SWIG_fail;
7955 PyThreadState* __tstate = wxPyBeginAllowThreads();
7956 result = (PyObject *)wxIntersectRect(arg1,arg2);
7957 wxPyEndAllowThreads(__tstate);
7958 if (PyErr_Occurred()) SWIG_fail;
7959 }
7960 resultobj = result;
7961 return resultobj;
7962 fail:
7963 return NULL;
7964 }
7965
7966
7967 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7968 PyObject *resultobj = 0;
7969 double arg1 = (double) 0.0 ;
7970 double arg2 = (double) 0.0 ;
7971 wxPoint2D *result = 0 ;
7972 double val1 ;
7973 int ecode1 = 0 ;
7974 double val2 ;
7975 int ecode2 = 0 ;
7976 PyObject * obj0 = 0 ;
7977 PyObject * obj1 = 0 ;
7978 char * kwnames[] = {
7979 (char *) "x",(char *) "y", NULL
7980 };
7981
7982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7983 if (obj0) {
7984 ecode1 = SWIG_AsVal_double(obj0, &val1);
7985 if (!SWIG_IsOK(ecode1)) {
7986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7987 }
7988 arg1 = static_cast< double >(val1);
7989 }
7990 if (obj1) {
7991 ecode2 = SWIG_AsVal_double(obj1, &val2);
7992 if (!SWIG_IsOK(ecode2)) {
7993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7994 }
7995 arg2 = static_cast< double >(val2);
7996 }
7997 {
7998 PyThreadState* __tstate = wxPyBeginAllowThreads();
7999 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8000 wxPyEndAllowThreads(__tstate);
8001 if (PyErr_Occurred()) SWIG_fail;
8002 }
8003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8004 return resultobj;
8005 fail:
8006 return NULL;
8007 }
8008
8009
8010 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8011 PyObject *resultobj = 0;
8012 wxPoint2D *arg1 = 0 ;
8013 wxPoint2D *result = 0 ;
8014 wxPoint2D temp1 ;
8015 PyObject * obj0 = 0 ;
8016 char * kwnames[] = {
8017 (char *) "pt", NULL
8018 };
8019
8020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8021 {
8022 arg1 = &temp1;
8023 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8024 }
8025 {
8026 PyThreadState* __tstate = wxPyBeginAllowThreads();
8027 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8028 wxPyEndAllowThreads(__tstate);
8029 if (PyErr_Occurred()) SWIG_fail;
8030 }
8031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8032 return resultobj;
8033 fail:
8034 return NULL;
8035 }
8036
8037
8038 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8039 PyObject *resultobj = 0;
8040 wxPoint *arg1 = 0 ;
8041 wxPoint2D *result = 0 ;
8042 wxPoint temp1 ;
8043 PyObject * obj0 = 0 ;
8044 char * kwnames[] = {
8045 (char *) "pt", NULL
8046 };
8047
8048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8049 {
8050 arg1 = &temp1;
8051 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8052 }
8053 {
8054 PyThreadState* __tstate = wxPyBeginAllowThreads();
8055 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8056 wxPyEndAllowThreads(__tstate);
8057 if (PyErr_Occurred()) SWIG_fail;
8058 }
8059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8060 return resultobj;
8061 fail:
8062 return NULL;
8063 }
8064
8065
8066 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8067 PyObject *resultobj = 0;
8068 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8069 int *arg2 = (int *) 0 ;
8070 int *arg3 = (int *) 0 ;
8071 void *argp1 = 0 ;
8072 int res1 = 0 ;
8073 int temp2 ;
8074 int res2 = SWIG_TMPOBJ ;
8075 int temp3 ;
8076 int res3 = SWIG_TMPOBJ ;
8077 PyObject *swig_obj[1] ;
8078
8079 arg2 = &temp2;
8080 arg3 = &temp3;
8081 if (!args) SWIG_fail;
8082 swig_obj[0] = args;
8083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8084 if (!SWIG_IsOK(res1)) {
8085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8086 }
8087 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8088 {
8089 PyThreadState* __tstate = wxPyBeginAllowThreads();
8090 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8091 wxPyEndAllowThreads(__tstate);
8092 if (PyErr_Occurred()) SWIG_fail;
8093 }
8094 resultobj = SWIG_Py_Void();
8095 if (SWIG_IsTmpObj(res2)) {
8096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8097 } else {
8098 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8099 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8100 }
8101 if (SWIG_IsTmpObj(res3)) {
8102 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8103 } else {
8104 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8105 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8106 }
8107 return resultobj;
8108 fail:
8109 return NULL;
8110 }
8111
8112
8113 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8114 PyObject *resultobj = 0;
8115 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8116 int *arg2 = (int *) 0 ;
8117 int *arg3 = (int *) 0 ;
8118 void *argp1 = 0 ;
8119 int res1 = 0 ;
8120 int temp2 ;
8121 int res2 = SWIG_TMPOBJ ;
8122 int temp3 ;
8123 int res3 = SWIG_TMPOBJ ;
8124 PyObject *swig_obj[1] ;
8125
8126 arg2 = &temp2;
8127 arg3 = &temp3;
8128 if (!args) SWIG_fail;
8129 swig_obj[0] = args;
8130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8131 if (!SWIG_IsOK(res1)) {
8132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8133 }
8134 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8135 {
8136 PyThreadState* __tstate = wxPyBeginAllowThreads();
8137 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 resultobj = SWIG_Py_Void();
8142 if (SWIG_IsTmpObj(res2)) {
8143 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8144 } else {
8145 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8146 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8147 }
8148 if (SWIG_IsTmpObj(res3)) {
8149 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8150 } else {
8151 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8152 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8153 }
8154 return resultobj;
8155 fail:
8156 return NULL;
8157 }
8158
8159
8160 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8161 PyObject *resultobj = 0;
8162 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8163 double result;
8164 void *argp1 = 0 ;
8165 int res1 = 0 ;
8166 PyObject *swig_obj[1] ;
8167
8168 if (!args) SWIG_fail;
8169 swig_obj[0] = args;
8170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8171 if (!SWIG_IsOK(res1)) {
8172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8173 }
8174 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8175 {
8176 PyThreadState* __tstate = wxPyBeginAllowThreads();
8177 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8178 wxPyEndAllowThreads(__tstate);
8179 if (PyErr_Occurred()) SWIG_fail;
8180 }
8181 resultobj = SWIG_From_double(static_cast< double >(result));
8182 return resultobj;
8183 fail:
8184 return NULL;
8185 }
8186
8187
8188 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8189 PyObject *resultobj = 0;
8190 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8191 double result;
8192 void *argp1 = 0 ;
8193 int res1 = 0 ;
8194 PyObject *swig_obj[1] ;
8195
8196 if (!args) SWIG_fail;
8197 swig_obj[0] = args;
8198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8199 if (!SWIG_IsOK(res1)) {
8200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8201 }
8202 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8203 {
8204 PyThreadState* __tstate = wxPyBeginAllowThreads();
8205 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8206 wxPyEndAllowThreads(__tstate);
8207 if (PyErr_Occurred()) SWIG_fail;
8208 }
8209 resultobj = SWIG_From_double(static_cast< double >(result));
8210 return resultobj;
8211 fail:
8212 return NULL;
8213 }
8214
8215
8216 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8217 PyObject *resultobj = 0;
8218 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8219 double arg2 ;
8220 void *argp1 = 0 ;
8221 int res1 = 0 ;
8222 double val2 ;
8223 int ecode2 = 0 ;
8224 PyObject * obj0 = 0 ;
8225 PyObject * obj1 = 0 ;
8226 char * kwnames[] = {
8227 (char *) "self",(char *) "length", NULL
8228 };
8229
8230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8232 if (!SWIG_IsOK(res1)) {
8233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8234 }
8235 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8236 ecode2 = SWIG_AsVal_double(obj1, &val2);
8237 if (!SWIG_IsOK(ecode2)) {
8238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8239 }
8240 arg2 = static_cast< double >(val2);
8241 {
8242 PyThreadState* __tstate = wxPyBeginAllowThreads();
8243 (arg1)->SetVectorLength(arg2);
8244 wxPyEndAllowThreads(__tstate);
8245 if (PyErr_Occurred()) SWIG_fail;
8246 }
8247 resultobj = SWIG_Py_Void();
8248 return resultobj;
8249 fail:
8250 return NULL;
8251 }
8252
8253
8254 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8255 PyObject *resultobj = 0;
8256 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8257 double arg2 ;
8258 void *argp1 = 0 ;
8259 int res1 = 0 ;
8260 double val2 ;
8261 int ecode2 = 0 ;
8262 PyObject * obj0 = 0 ;
8263 PyObject * obj1 = 0 ;
8264 char * kwnames[] = {
8265 (char *) "self",(char *) "degrees", NULL
8266 };
8267
8268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8270 if (!SWIG_IsOK(res1)) {
8271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8272 }
8273 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8274 ecode2 = SWIG_AsVal_double(obj1, &val2);
8275 if (!SWIG_IsOK(ecode2)) {
8276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8277 }
8278 arg2 = static_cast< double >(val2);
8279 {
8280 PyThreadState* __tstate = wxPyBeginAllowThreads();
8281 (arg1)->SetVectorAngle(arg2);
8282 wxPyEndAllowThreads(__tstate);
8283 if (PyErr_Occurred()) SWIG_fail;
8284 }
8285 resultobj = SWIG_Py_Void();
8286 return resultobj;
8287 fail:
8288 return NULL;
8289 }
8290
8291
8292 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8293 PyObject *resultobj = 0;
8294 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8295 wxPoint2D *arg2 = 0 ;
8296 double result;
8297 void *argp1 = 0 ;
8298 int res1 = 0 ;
8299 wxPoint2D temp2 ;
8300 PyObject * obj0 = 0 ;
8301 PyObject * obj1 = 0 ;
8302 char * kwnames[] = {
8303 (char *) "self",(char *) "pt", NULL
8304 };
8305
8306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8308 if (!SWIG_IsOK(res1)) {
8309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8310 }
8311 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8312 {
8313 arg2 = &temp2;
8314 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8315 }
8316 {
8317 PyThreadState* __tstate = wxPyBeginAllowThreads();
8318 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8319 wxPyEndAllowThreads(__tstate);
8320 if (PyErr_Occurred()) SWIG_fail;
8321 }
8322 resultobj = SWIG_From_double(static_cast< double >(result));
8323 return resultobj;
8324 fail:
8325 return NULL;
8326 }
8327
8328
8329 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8330 PyObject *resultobj = 0;
8331 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8332 wxPoint2D *arg2 = 0 ;
8333 double result;
8334 void *argp1 = 0 ;
8335 int res1 = 0 ;
8336 wxPoint2D temp2 ;
8337 PyObject * obj0 = 0 ;
8338 PyObject * obj1 = 0 ;
8339 char * kwnames[] = {
8340 (char *) "self",(char *) "pt", NULL
8341 };
8342
8343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8345 if (!SWIG_IsOK(res1)) {
8346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8347 }
8348 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8349 {
8350 arg2 = &temp2;
8351 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8352 }
8353 {
8354 PyThreadState* __tstate = wxPyBeginAllowThreads();
8355 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8356 wxPyEndAllowThreads(__tstate);
8357 if (PyErr_Occurred()) SWIG_fail;
8358 }
8359 resultobj = SWIG_From_double(static_cast< double >(result));
8360 return resultobj;
8361 fail:
8362 return NULL;
8363 }
8364
8365
8366 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8367 PyObject *resultobj = 0;
8368 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8369 wxPoint2D *arg2 = 0 ;
8370 double result;
8371 void *argp1 = 0 ;
8372 int res1 = 0 ;
8373 wxPoint2D temp2 ;
8374 PyObject * obj0 = 0 ;
8375 PyObject * obj1 = 0 ;
8376 char * kwnames[] = {
8377 (char *) "self",(char *) "vec", NULL
8378 };
8379
8380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8382 if (!SWIG_IsOK(res1)) {
8383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8384 }
8385 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8386 {
8387 arg2 = &temp2;
8388 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8389 }
8390 {
8391 PyThreadState* __tstate = wxPyBeginAllowThreads();
8392 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8393 wxPyEndAllowThreads(__tstate);
8394 if (PyErr_Occurred()) SWIG_fail;
8395 }
8396 resultobj = SWIG_From_double(static_cast< double >(result));
8397 return resultobj;
8398 fail:
8399 return NULL;
8400 }
8401
8402
8403 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8404 PyObject *resultobj = 0;
8405 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8406 wxPoint2D *arg2 = 0 ;
8407 double result;
8408 void *argp1 = 0 ;
8409 int res1 = 0 ;
8410 wxPoint2D temp2 ;
8411 PyObject * obj0 = 0 ;
8412 PyObject * obj1 = 0 ;
8413 char * kwnames[] = {
8414 (char *) "self",(char *) "vec", NULL
8415 };
8416
8417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8419 if (!SWIG_IsOK(res1)) {
8420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8421 }
8422 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8423 {
8424 arg2 = &temp2;
8425 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8426 }
8427 {
8428 PyThreadState* __tstate = wxPyBeginAllowThreads();
8429 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8430 wxPyEndAllowThreads(__tstate);
8431 if (PyErr_Occurred()) SWIG_fail;
8432 }
8433 resultobj = SWIG_From_double(static_cast< double >(result));
8434 return resultobj;
8435 fail:
8436 return NULL;
8437 }
8438
8439
8440 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8441 PyObject *resultobj = 0;
8442 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8443 wxPoint2D result;
8444 void *argp1 = 0 ;
8445 int res1 = 0 ;
8446 PyObject *swig_obj[1] ;
8447
8448 if (!args) SWIG_fail;
8449 swig_obj[0] = args;
8450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8451 if (!SWIG_IsOK(res1)) {
8452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8453 }
8454 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8455 {
8456 PyThreadState* __tstate = wxPyBeginAllowThreads();
8457 result = (arg1)->operator -();
8458 wxPyEndAllowThreads(__tstate);
8459 if (PyErr_Occurred()) SWIG_fail;
8460 }
8461 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8462 return resultobj;
8463 fail:
8464 return NULL;
8465 }
8466
8467
8468 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8469 PyObject *resultobj = 0;
8470 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8471 wxPoint2D *arg2 = 0 ;
8472 wxPoint2D *result = 0 ;
8473 void *argp1 = 0 ;
8474 int res1 = 0 ;
8475 wxPoint2D temp2 ;
8476 PyObject * obj0 = 0 ;
8477 PyObject * obj1 = 0 ;
8478 char * kwnames[] = {
8479 (char *) "self",(char *) "pt", NULL
8480 };
8481
8482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8484 if (!SWIG_IsOK(res1)) {
8485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8486 }
8487 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8488 {
8489 arg2 = &temp2;
8490 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8491 }
8492 {
8493 PyThreadState* __tstate = wxPyBeginAllowThreads();
8494 {
8495 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8496 result = (wxPoint2D *) &_result_ref;
8497 }
8498 wxPyEndAllowThreads(__tstate);
8499 if (PyErr_Occurred()) SWIG_fail;
8500 }
8501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8502 return resultobj;
8503 fail:
8504 return NULL;
8505 }
8506
8507
8508 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8509 PyObject *resultobj = 0;
8510 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8511 wxPoint2D *arg2 = 0 ;
8512 wxPoint2D *result = 0 ;
8513 void *argp1 = 0 ;
8514 int res1 = 0 ;
8515 wxPoint2D temp2 ;
8516 PyObject * obj0 = 0 ;
8517 PyObject * obj1 = 0 ;
8518 char * kwnames[] = {
8519 (char *) "self",(char *) "pt", NULL
8520 };
8521
8522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8524 if (!SWIG_IsOK(res1)) {
8525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8526 }
8527 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8528 {
8529 arg2 = &temp2;
8530 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8531 }
8532 {
8533 PyThreadState* __tstate = wxPyBeginAllowThreads();
8534 {
8535 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8536 result = (wxPoint2D *) &_result_ref;
8537 }
8538 wxPyEndAllowThreads(__tstate);
8539 if (PyErr_Occurred()) SWIG_fail;
8540 }
8541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8542 return resultobj;
8543 fail:
8544 return NULL;
8545 }
8546
8547
8548 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8549 PyObject *resultobj = 0;
8550 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8551 wxPoint2D *arg2 = 0 ;
8552 wxPoint2D *result = 0 ;
8553 void *argp1 = 0 ;
8554 int res1 = 0 ;
8555 wxPoint2D temp2 ;
8556 PyObject * obj0 = 0 ;
8557 PyObject * obj1 = 0 ;
8558 char * kwnames[] = {
8559 (char *) "self",(char *) "pt", NULL
8560 };
8561
8562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8564 if (!SWIG_IsOK(res1)) {
8565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8566 }
8567 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8568 {
8569 arg2 = &temp2;
8570 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8571 }
8572 {
8573 PyThreadState* __tstate = wxPyBeginAllowThreads();
8574 {
8575 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8576 result = (wxPoint2D *) &_result_ref;
8577 }
8578 wxPyEndAllowThreads(__tstate);
8579 if (PyErr_Occurred()) SWIG_fail;
8580 }
8581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8582 return resultobj;
8583 fail:
8584 return NULL;
8585 }
8586
8587
8588 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8589 PyObject *resultobj = 0;
8590 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8591 wxPoint2D *arg2 = 0 ;
8592 wxPoint2D *result = 0 ;
8593 void *argp1 = 0 ;
8594 int res1 = 0 ;
8595 wxPoint2D temp2 ;
8596 PyObject * obj0 = 0 ;
8597 PyObject * obj1 = 0 ;
8598 char * kwnames[] = {
8599 (char *) "self",(char *) "pt", NULL
8600 };
8601
8602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8604 if (!SWIG_IsOK(res1)) {
8605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8606 }
8607 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8608 {
8609 arg2 = &temp2;
8610 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8611 }
8612 {
8613 PyThreadState* __tstate = wxPyBeginAllowThreads();
8614 {
8615 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8616 result = (wxPoint2D *) &_result_ref;
8617 }
8618 wxPyEndAllowThreads(__tstate);
8619 if (PyErr_Occurred()) SWIG_fail;
8620 }
8621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8622 return resultobj;
8623 fail:
8624 return NULL;
8625 }
8626
8627
8628 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8629 PyObject *resultobj = 0;
8630 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8631 PyObject *arg2 = (PyObject *) 0 ;
8632 bool result;
8633 void *argp1 = 0 ;
8634 int res1 = 0 ;
8635 PyObject * obj0 = 0 ;
8636 PyObject * obj1 = 0 ;
8637 char * kwnames[] = {
8638 (char *) "self",(char *) "other", NULL
8639 };
8640
8641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8643 if (!SWIG_IsOK(res1)) {
8644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8645 }
8646 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8647 arg2 = obj1;
8648 {
8649 result = (bool)wxPoint2D___eq__(arg1,arg2);
8650 if (PyErr_Occurred()) SWIG_fail;
8651 }
8652 {
8653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8654 }
8655 return resultobj;
8656 fail:
8657 return NULL;
8658 }
8659
8660
8661 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8662 PyObject *resultobj = 0;
8663 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8664 PyObject *arg2 = (PyObject *) 0 ;
8665 bool result;
8666 void *argp1 = 0 ;
8667 int res1 = 0 ;
8668 PyObject * obj0 = 0 ;
8669 PyObject * obj1 = 0 ;
8670 char * kwnames[] = {
8671 (char *) "self",(char *) "other", NULL
8672 };
8673
8674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8676 if (!SWIG_IsOK(res1)) {
8677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8678 }
8679 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8680 arg2 = obj1;
8681 {
8682 result = (bool)wxPoint2D___ne__(arg1,arg2);
8683 if (PyErr_Occurred()) SWIG_fail;
8684 }
8685 {
8686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8687 }
8688 return resultobj;
8689 fail:
8690 return NULL;
8691 }
8692
8693
8694 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8695 PyObject *resultobj = 0;
8696 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8697 double arg2 ;
8698 void *argp1 = 0 ;
8699 int res1 = 0 ;
8700 double val2 ;
8701 int ecode2 = 0 ;
8702 PyObject *swig_obj[2] ;
8703
8704 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8706 if (!SWIG_IsOK(res1)) {
8707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8708 }
8709 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8710 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8711 if (!SWIG_IsOK(ecode2)) {
8712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8713 }
8714 arg2 = static_cast< double >(val2);
8715 if (arg1) (arg1)->m_x = arg2;
8716
8717 resultobj = SWIG_Py_Void();
8718 return resultobj;
8719 fail:
8720 return NULL;
8721 }
8722
8723
8724 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8725 PyObject *resultobj = 0;
8726 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8727 double result;
8728 void *argp1 = 0 ;
8729 int res1 = 0 ;
8730 PyObject *swig_obj[1] ;
8731
8732 if (!args) SWIG_fail;
8733 swig_obj[0] = args;
8734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8735 if (!SWIG_IsOK(res1)) {
8736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8737 }
8738 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8739 result = (double) ((arg1)->m_x);
8740 resultobj = SWIG_From_double(static_cast< double >(result));
8741 return resultobj;
8742 fail:
8743 return NULL;
8744 }
8745
8746
8747 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8748 PyObject *resultobj = 0;
8749 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8750 double arg2 ;
8751 void *argp1 = 0 ;
8752 int res1 = 0 ;
8753 double val2 ;
8754 int ecode2 = 0 ;
8755 PyObject *swig_obj[2] ;
8756
8757 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8759 if (!SWIG_IsOK(res1)) {
8760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8761 }
8762 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8763 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8764 if (!SWIG_IsOK(ecode2)) {
8765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8766 }
8767 arg2 = static_cast< double >(val2);
8768 if (arg1) (arg1)->m_y = arg2;
8769
8770 resultobj = SWIG_Py_Void();
8771 return resultobj;
8772 fail:
8773 return NULL;
8774 }
8775
8776
8777 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8778 PyObject *resultobj = 0;
8779 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8780 double result;
8781 void *argp1 = 0 ;
8782 int res1 = 0 ;
8783 PyObject *swig_obj[1] ;
8784
8785 if (!args) SWIG_fail;
8786 swig_obj[0] = args;
8787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8788 if (!SWIG_IsOK(res1)) {
8789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8790 }
8791 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8792 result = (double) ((arg1)->m_y);
8793 resultobj = SWIG_From_double(static_cast< double >(result));
8794 return resultobj;
8795 fail:
8796 return NULL;
8797 }
8798
8799
8800 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8801 PyObject *resultobj = 0;
8802 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8803 double arg2 = (double) 0 ;
8804 double arg3 = (double) 0 ;
8805 void *argp1 = 0 ;
8806 int res1 = 0 ;
8807 double val2 ;
8808 int ecode2 = 0 ;
8809 double val3 ;
8810 int ecode3 = 0 ;
8811 PyObject * obj0 = 0 ;
8812 PyObject * obj1 = 0 ;
8813 PyObject * obj2 = 0 ;
8814 char * kwnames[] = {
8815 (char *) "self",(char *) "x",(char *) "y", NULL
8816 };
8817
8818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8820 if (!SWIG_IsOK(res1)) {
8821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8822 }
8823 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8824 if (obj1) {
8825 ecode2 = SWIG_AsVal_double(obj1, &val2);
8826 if (!SWIG_IsOK(ecode2)) {
8827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8828 }
8829 arg2 = static_cast< double >(val2);
8830 }
8831 if (obj2) {
8832 ecode3 = SWIG_AsVal_double(obj2, &val3);
8833 if (!SWIG_IsOK(ecode3)) {
8834 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8835 }
8836 arg3 = static_cast< double >(val3);
8837 }
8838 {
8839 PyThreadState* __tstate = wxPyBeginAllowThreads();
8840 wxPoint2D_Set(arg1,arg2,arg3);
8841 wxPyEndAllowThreads(__tstate);
8842 if (PyErr_Occurred()) SWIG_fail;
8843 }
8844 resultobj = SWIG_Py_Void();
8845 return resultobj;
8846 fail:
8847 return NULL;
8848 }
8849
8850
8851 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8852 PyObject *resultobj = 0;
8853 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8854 PyObject *result = 0 ;
8855 void *argp1 = 0 ;
8856 int res1 = 0 ;
8857 PyObject *swig_obj[1] ;
8858
8859 if (!args) SWIG_fail;
8860 swig_obj[0] = args;
8861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8862 if (!SWIG_IsOK(res1)) {
8863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8864 }
8865 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8866 {
8867 PyThreadState* __tstate = wxPyBeginAllowThreads();
8868 result = (PyObject *)wxPoint2D_Get(arg1);
8869 wxPyEndAllowThreads(__tstate);
8870 if (PyErr_Occurred()) SWIG_fail;
8871 }
8872 resultobj = result;
8873 return resultobj;
8874 fail:
8875 return NULL;
8876 }
8877
8878
8879 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8880 PyObject *obj;
8881 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8882 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8883 return SWIG_Py_Void();
8884 }
8885
8886 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8887 return SWIG_Python_InitShadowInstance(args);
8888 }
8889
8890 SWIGINTERN int DefaultPosition_set(PyObject *) {
8891 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8892 return 1;
8893 }
8894
8895
8896 SWIGINTERN PyObject *DefaultPosition_get(void) {
8897 PyObject *pyobj = 0;
8898
8899 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8900 return pyobj;
8901 }
8902
8903
8904 SWIGINTERN int DefaultSize_set(PyObject *) {
8905 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8906 return 1;
8907 }
8908
8909
8910 SWIGINTERN PyObject *DefaultSize_get(void) {
8911 PyObject *pyobj = 0;
8912
8913 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8914 return pyobj;
8915 }
8916
8917
8918 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8919 PyObject *resultobj = 0;
8920 PyObject *arg1 = (PyObject *) 0 ;
8921 wxPyInputStream *result = 0 ;
8922 PyObject * obj0 = 0 ;
8923 char * kwnames[] = {
8924 (char *) "p", NULL
8925 };
8926
8927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8928 arg1 = obj0;
8929 {
8930 PyThreadState* __tstate = wxPyBeginAllowThreads();
8931 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8932 wxPyEndAllowThreads(__tstate);
8933 if (PyErr_Occurred()) SWIG_fail;
8934 }
8935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8936 return resultobj;
8937 fail:
8938 return NULL;
8939 }
8940
8941
8942 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8943 PyObject *resultobj = 0;
8944 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8945 void *argp1 = 0 ;
8946 int res1 = 0 ;
8947 PyObject *swig_obj[1] ;
8948
8949 if (!args) SWIG_fail;
8950 swig_obj[0] = args;
8951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8952 if (!SWIG_IsOK(res1)) {
8953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8954 }
8955 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8956 {
8957 PyThreadState* __tstate = wxPyBeginAllowThreads();
8958 delete arg1;
8959
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 resultobj = SWIG_Py_Void();
8964 return resultobj;
8965 fail:
8966 return NULL;
8967 }
8968
8969
8970 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8971 PyObject *resultobj = 0;
8972 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8973 void *argp1 = 0 ;
8974 int res1 = 0 ;
8975 PyObject *swig_obj[1] ;
8976
8977 if (!args) SWIG_fail;
8978 swig_obj[0] = args;
8979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8980 if (!SWIG_IsOK(res1)) {
8981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8982 }
8983 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8984 {
8985 PyThreadState* __tstate = wxPyBeginAllowThreads();
8986 (arg1)->close();
8987 wxPyEndAllowThreads(__tstate);
8988 if (PyErr_Occurred()) SWIG_fail;
8989 }
8990 resultobj = SWIG_Py_Void();
8991 return resultobj;
8992 fail:
8993 return NULL;
8994 }
8995
8996
8997 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8998 PyObject *resultobj = 0;
8999 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9000 void *argp1 = 0 ;
9001 int res1 = 0 ;
9002 PyObject *swig_obj[1] ;
9003
9004 if (!args) SWIG_fail;
9005 swig_obj[0] = args;
9006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9007 if (!SWIG_IsOK(res1)) {
9008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9009 }
9010 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9011 {
9012 PyThreadState* __tstate = wxPyBeginAllowThreads();
9013 (arg1)->flush();
9014 wxPyEndAllowThreads(__tstate);
9015 if (PyErr_Occurred()) SWIG_fail;
9016 }
9017 resultobj = SWIG_Py_Void();
9018 return resultobj;
9019 fail:
9020 return NULL;
9021 }
9022
9023
9024 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9025 PyObject *resultobj = 0;
9026 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9027 bool result;
9028 void *argp1 = 0 ;
9029 int res1 = 0 ;
9030 PyObject *swig_obj[1] ;
9031
9032 if (!args) SWIG_fail;
9033 swig_obj[0] = args;
9034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9035 if (!SWIG_IsOK(res1)) {
9036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9037 }
9038 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9039 {
9040 PyThreadState* __tstate = wxPyBeginAllowThreads();
9041 result = (bool)(arg1)->eof();
9042 wxPyEndAllowThreads(__tstate);
9043 if (PyErr_Occurred()) SWIG_fail;
9044 }
9045 {
9046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9047 }
9048 return resultobj;
9049 fail:
9050 return NULL;
9051 }
9052
9053
9054 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9055 PyObject *resultobj = 0;
9056 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9057 int arg2 = (int) -1 ;
9058 PyObject *result = 0 ;
9059 void *argp1 = 0 ;
9060 int res1 = 0 ;
9061 int val2 ;
9062 int ecode2 = 0 ;
9063 PyObject * obj0 = 0 ;
9064 PyObject * obj1 = 0 ;
9065 char * kwnames[] = {
9066 (char *) "self",(char *) "size", NULL
9067 };
9068
9069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9071 if (!SWIG_IsOK(res1)) {
9072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9073 }
9074 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9075 if (obj1) {
9076 ecode2 = SWIG_AsVal_int(obj1, &val2);
9077 if (!SWIG_IsOK(ecode2)) {
9078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9079 }
9080 arg2 = static_cast< int >(val2);
9081 }
9082 {
9083 PyThreadState* __tstate = wxPyBeginAllowThreads();
9084 result = (PyObject *)(arg1)->read(arg2);
9085 wxPyEndAllowThreads(__tstate);
9086 if (PyErr_Occurred()) SWIG_fail;
9087 }
9088 resultobj = result;
9089 return resultobj;
9090 fail:
9091 return NULL;
9092 }
9093
9094
9095 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9096 PyObject *resultobj = 0;
9097 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9098 int arg2 = (int) -1 ;
9099 PyObject *result = 0 ;
9100 void *argp1 = 0 ;
9101 int res1 = 0 ;
9102 int val2 ;
9103 int ecode2 = 0 ;
9104 PyObject * obj0 = 0 ;
9105 PyObject * obj1 = 0 ;
9106 char * kwnames[] = {
9107 (char *) "self",(char *) "size", NULL
9108 };
9109
9110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9112 if (!SWIG_IsOK(res1)) {
9113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9114 }
9115 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9116 if (obj1) {
9117 ecode2 = SWIG_AsVal_int(obj1, &val2);
9118 if (!SWIG_IsOK(ecode2)) {
9119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9120 }
9121 arg2 = static_cast< int >(val2);
9122 }
9123 {
9124 PyThreadState* __tstate = wxPyBeginAllowThreads();
9125 result = (PyObject *)(arg1)->readline(arg2);
9126 wxPyEndAllowThreads(__tstate);
9127 if (PyErr_Occurred()) SWIG_fail;
9128 }
9129 resultobj = result;
9130 return resultobj;
9131 fail:
9132 return NULL;
9133 }
9134
9135
9136 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9137 PyObject *resultobj = 0;
9138 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9139 int arg2 = (int) -1 ;
9140 PyObject *result = 0 ;
9141 void *argp1 = 0 ;
9142 int res1 = 0 ;
9143 int val2 ;
9144 int ecode2 = 0 ;
9145 PyObject * obj0 = 0 ;
9146 PyObject * obj1 = 0 ;
9147 char * kwnames[] = {
9148 (char *) "self",(char *) "sizehint", NULL
9149 };
9150
9151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9153 if (!SWIG_IsOK(res1)) {
9154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9155 }
9156 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9157 if (obj1) {
9158 ecode2 = SWIG_AsVal_int(obj1, &val2);
9159 if (!SWIG_IsOK(ecode2)) {
9160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9161 }
9162 arg2 = static_cast< int >(val2);
9163 }
9164 {
9165 PyThreadState* __tstate = wxPyBeginAllowThreads();
9166 result = (PyObject *)(arg1)->readlines(arg2);
9167 wxPyEndAllowThreads(__tstate);
9168 if (PyErr_Occurred()) SWIG_fail;
9169 }
9170 resultobj = result;
9171 return resultobj;
9172 fail:
9173 return NULL;
9174 }
9175
9176
9177 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9178 PyObject *resultobj = 0;
9179 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9180 int arg2 ;
9181 int arg3 = (int) 0 ;
9182 void *argp1 = 0 ;
9183 int res1 = 0 ;
9184 int val2 ;
9185 int ecode2 = 0 ;
9186 int val3 ;
9187 int ecode3 = 0 ;
9188 PyObject * obj0 = 0 ;
9189 PyObject * obj1 = 0 ;
9190 PyObject * obj2 = 0 ;
9191 char * kwnames[] = {
9192 (char *) "self",(char *) "offset",(char *) "whence", NULL
9193 };
9194
9195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9197 if (!SWIG_IsOK(res1)) {
9198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9199 }
9200 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9201 ecode2 = SWIG_AsVal_int(obj1, &val2);
9202 if (!SWIG_IsOK(ecode2)) {
9203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9204 }
9205 arg2 = static_cast< int >(val2);
9206 if (obj2) {
9207 ecode3 = SWIG_AsVal_int(obj2, &val3);
9208 if (!SWIG_IsOK(ecode3)) {
9209 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9210 }
9211 arg3 = static_cast< int >(val3);
9212 }
9213 {
9214 PyThreadState* __tstate = wxPyBeginAllowThreads();
9215 (arg1)->seek(arg2,arg3);
9216 wxPyEndAllowThreads(__tstate);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 resultobj = SWIG_Py_Void();
9220 return resultobj;
9221 fail:
9222 return NULL;
9223 }
9224
9225
9226 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9227 PyObject *resultobj = 0;
9228 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9229 int result;
9230 void *argp1 = 0 ;
9231 int res1 = 0 ;
9232 PyObject *swig_obj[1] ;
9233
9234 if (!args) SWIG_fail;
9235 swig_obj[0] = args;
9236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9237 if (!SWIG_IsOK(res1)) {
9238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9239 }
9240 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9241 {
9242 PyThreadState* __tstate = wxPyBeginAllowThreads();
9243 result = (int)(arg1)->tell();
9244 wxPyEndAllowThreads(__tstate);
9245 if (PyErr_Occurred()) SWIG_fail;
9246 }
9247 resultobj = SWIG_From_int(static_cast< int >(result));
9248 return resultobj;
9249 fail:
9250 return NULL;
9251 }
9252
9253
9254 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9255 PyObject *resultobj = 0;
9256 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9257 char result;
9258 void *argp1 = 0 ;
9259 int res1 = 0 ;
9260 PyObject *swig_obj[1] ;
9261
9262 if (!args) SWIG_fail;
9263 swig_obj[0] = args;
9264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9265 if (!SWIG_IsOK(res1)) {
9266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9267 }
9268 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9269 {
9270 PyThreadState* __tstate = wxPyBeginAllowThreads();
9271 result = (char)(arg1)->Peek();
9272 wxPyEndAllowThreads(__tstate);
9273 if (PyErr_Occurred()) SWIG_fail;
9274 }
9275 resultobj = SWIG_From_char(static_cast< char >(result));
9276 return resultobj;
9277 fail:
9278 return NULL;
9279 }
9280
9281
9282 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9283 PyObject *resultobj = 0;
9284 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9285 char result;
9286 void *argp1 = 0 ;
9287 int res1 = 0 ;
9288 PyObject *swig_obj[1] ;
9289
9290 if (!args) SWIG_fail;
9291 swig_obj[0] = args;
9292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9293 if (!SWIG_IsOK(res1)) {
9294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9295 }
9296 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9297 {
9298 PyThreadState* __tstate = wxPyBeginAllowThreads();
9299 result = (char)(arg1)->GetC();
9300 wxPyEndAllowThreads(__tstate);
9301 if (PyErr_Occurred()) SWIG_fail;
9302 }
9303 resultobj = SWIG_From_char(static_cast< char >(result));
9304 return resultobj;
9305 fail:
9306 return NULL;
9307 }
9308
9309
9310 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9311 PyObject *resultobj = 0;
9312 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9313 size_t result;
9314 void *argp1 = 0 ;
9315 int res1 = 0 ;
9316 PyObject *swig_obj[1] ;
9317
9318 if (!args) SWIG_fail;
9319 swig_obj[0] = args;
9320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9321 if (!SWIG_IsOK(res1)) {
9322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9323 }
9324 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9325 {
9326 PyThreadState* __tstate = wxPyBeginAllowThreads();
9327 result = (size_t)(arg1)->LastRead();
9328 wxPyEndAllowThreads(__tstate);
9329 if (PyErr_Occurred()) SWIG_fail;
9330 }
9331 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9332 return resultobj;
9333 fail:
9334 return NULL;
9335 }
9336
9337
9338 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9339 PyObject *resultobj = 0;
9340 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9341 bool result;
9342 void *argp1 = 0 ;
9343 int res1 = 0 ;
9344 PyObject *swig_obj[1] ;
9345
9346 if (!args) SWIG_fail;
9347 swig_obj[0] = args;
9348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9349 if (!SWIG_IsOK(res1)) {
9350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9351 }
9352 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9353 {
9354 PyThreadState* __tstate = wxPyBeginAllowThreads();
9355 result = (bool)(arg1)->CanRead();
9356 wxPyEndAllowThreads(__tstate);
9357 if (PyErr_Occurred()) SWIG_fail;
9358 }
9359 {
9360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9361 }
9362 return resultobj;
9363 fail:
9364 return NULL;
9365 }
9366
9367
9368 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9369 PyObject *resultobj = 0;
9370 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9371 bool result;
9372 void *argp1 = 0 ;
9373 int res1 = 0 ;
9374 PyObject *swig_obj[1] ;
9375
9376 if (!args) SWIG_fail;
9377 swig_obj[0] = args;
9378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9379 if (!SWIG_IsOK(res1)) {
9380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9381 }
9382 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9383 {
9384 PyThreadState* __tstate = wxPyBeginAllowThreads();
9385 result = (bool)(arg1)->Eof();
9386 wxPyEndAllowThreads(__tstate);
9387 if (PyErr_Occurred()) SWIG_fail;
9388 }
9389 {
9390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9391 }
9392 return resultobj;
9393 fail:
9394 return NULL;
9395 }
9396
9397
9398 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9399 PyObject *resultobj = 0;
9400 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9401 char arg2 ;
9402 bool result;
9403 void *argp1 = 0 ;
9404 int res1 = 0 ;
9405 char val2 ;
9406 int ecode2 = 0 ;
9407 PyObject * obj0 = 0 ;
9408 PyObject * obj1 = 0 ;
9409 char * kwnames[] = {
9410 (char *) "self",(char *) "c", NULL
9411 };
9412
9413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9415 if (!SWIG_IsOK(res1)) {
9416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9417 }
9418 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9419 ecode2 = SWIG_AsVal_char(obj1, &val2);
9420 if (!SWIG_IsOK(ecode2)) {
9421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9422 }
9423 arg2 = static_cast< char >(val2);
9424 {
9425 PyThreadState* __tstate = wxPyBeginAllowThreads();
9426 result = (bool)(arg1)->Ungetch(arg2);
9427 wxPyEndAllowThreads(__tstate);
9428 if (PyErr_Occurred()) SWIG_fail;
9429 }
9430 {
9431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9432 }
9433 return resultobj;
9434 fail:
9435 return NULL;
9436 }
9437
9438
9439 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9440 PyObject *resultobj = 0;
9441 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9442 long arg2 ;
9443 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9444 long result;
9445 void *argp1 = 0 ;
9446 int res1 = 0 ;
9447 long val2 ;
9448 int ecode2 = 0 ;
9449 int val3 ;
9450 int ecode3 = 0 ;
9451 PyObject * obj0 = 0 ;
9452 PyObject * obj1 = 0 ;
9453 PyObject * obj2 = 0 ;
9454 char * kwnames[] = {
9455 (char *) "self",(char *) "pos",(char *) "mode", NULL
9456 };
9457
9458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9460 if (!SWIG_IsOK(res1)) {
9461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9462 }
9463 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9464 ecode2 = SWIG_AsVal_long(obj1, &val2);
9465 if (!SWIG_IsOK(ecode2)) {
9466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9467 }
9468 arg2 = static_cast< long >(val2);
9469 if (obj2) {
9470 ecode3 = SWIG_AsVal_int(obj2, &val3);
9471 if (!SWIG_IsOK(ecode3)) {
9472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9473 }
9474 arg3 = static_cast< wxSeekMode >(val3);
9475 }
9476 {
9477 PyThreadState* __tstate = wxPyBeginAllowThreads();
9478 result = (long)(arg1)->SeekI(arg2,arg3);
9479 wxPyEndAllowThreads(__tstate);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 resultobj = SWIG_From_long(static_cast< long >(result));
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9490 PyObject *resultobj = 0;
9491 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9492 long result;
9493 void *argp1 = 0 ;
9494 int res1 = 0 ;
9495 PyObject *swig_obj[1] ;
9496
9497 if (!args) SWIG_fail;
9498 swig_obj[0] = args;
9499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9500 if (!SWIG_IsOK(res1)) {
9501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9502 }
9503 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9504 {
9505 PyThreadState* __tstate = wxPyBeginAllowThreads();
9506 result = (long)(arg1)->TellI();
9507 wxPyEndAllowThreads(__tstate);
9508 if (PyErr_Occurred()) SWIG_fail;
9509 }
9510 resultobj = SWIG_From_long(static_cast< long >(result));
9511 return resultobj;
9512 fail:
9513 return NULL;
9514 }
9515
9516
9517 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9518 PyObject *obj;
9519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9520 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9521 return SWIG_Py_Void();
9522 }
9523
9524 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9525 return SWIG_Python_InitShadowInstance(args);
9526 }
9527
9528 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9529 PyObject *resultobj = 0;
9530 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9531 PyObject *arg2 = (PyObject *) 0 ;
9532 void *argp1 = 0 ;
9533 int res1 = 0 ;
9534 PyObject * obj0 = 0 ;
9535 PyObject * obj1 = 0 ;
9536 char * kwnames[] = {
9537 (char *) "self",(char *) "obj", NULL
9538 };
9539
9540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9542 if (!SWIG_IsOK(res1)) {
9543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9544 }
9545 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9546 arg2 = obj1;
9547 {
9548 PyThreadState* __tstate = wxPyBeginAllowThreads();
9549 wxOutputStream_write(arg1,arg2);
9550 wxPyEndAllowThreads(__tstate);
9551 if (PyErr_Occurred()) SWIG_fail;
9552 }
9553 resultobj = SWIG_Py_Void();
9554 return resultobj;
9555 fail:
9556 return NULL;
9557 }
9558
9559
9560 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9561 PyObject *resultobj = 0;
9562 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9563 size_t result;
9564 void *argp1 = 0 ;
9565 int res1 = 0 ;
9566 PyObject *swig_obj[1] ;
9567
9568 if (!args) SWIG_fail;
9569 swig_obj[0] = args;
9570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9571 if (!SWIG_IsOK(res1)) {
9572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9573 }
9574 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9575 {
9576 PyThreadState* __tstate = wxPyBeginAllowThreads();
9577 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9578 wxPyEndAllowThreads(__tstate);
9579 if (PyErr_Occurred()) SWIG_fail;
9580 }
9581 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9582 return resultobj;
9583 fail:
9584 return NULL;
9585 }
9586
9587
9588 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9589 PyObject *obj;
9590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9591 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9592 return SWIG_Py_Void();
9593 }
9594
9595 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9596 PyObject *resultobj = 0;
9597 wxInputStream *arg1 = (wxInputStream *) 0 ;
9598 wxString *arg2 = 0 ;
9599 wxString *arg3 = 0 ;
9600 wxString *arg4 = 0 ;
9601 wxDateTime arg5 ;
9602 wxFSFile *result = 0 ;
9603 wxPyInputStream *temp1 ;
9604 bool temp2 = false ;
9605 bool temp3 = false ;
9606 bool temp4 = false ;
9607 void *argp5 ;
9608 int res5 = 0 ;
9609 PyObject * obj0 = 0 ;
9610 PyObject * obj1 = 0 ;
9611 PyObject * obj2 = 0 ;
9612 PyObject * obj3 = 0 ;
9613 PyObject * obj4 = 0 ;
9614 char * kwnames[] = {
9615 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9616 };
9617
9618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9619 {
9620 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9621 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9622 } else {
9623 PyErr_Clear(); // clear the failure of the wxPyConvert above
9624 arg1 = wxPyCBInputStream_create(obj0, true);
9625 if (arg1 == NULL) {
9626 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9627 SWIG_fail;
9628 }
9629 }
9630 }
9631 {
9632 arg2 = wxString_in_helper(obj1);
9633 if (arg2 == NULL) SWIG_fail;
9634 temp2 = true;
9635 }
9636 {
9637 arg3 = wxString_in_helper(obj2);
9638 if (arg3 == NULL) SWIG_fail;
9639 temp3 = true;
9640 }
9641 {
9642 arg4 = wxString_in_helper(obj3);
9643 if (arg4 == NULL) SWIG_fail;
9644 temp4 = true;
9645 }
9646 {
9647 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9648 if (!SWIG_IsOK(res5)) {
9649 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9650 }
9651 if (!argp5) {
9652 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9653 } else {
9654 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9655 arg5 = *temp;
9656 if (SWIG_IsNewObj(res5)) delete temp;
9657 }
9658 }
9659 {
9660 PyThreadState* __tstate = wxPyBeginAllowThreads();
9661 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9662 wxPyEndAllowThreads(__tstate);
9663 if (PyErr_Occurred()) SWIG_fail;
9664 }
9665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9666 {
9667 if (temp2)
9668 delete arg2;
9669 }
9670 {
9671 if (temp3)
9672 delete arg3;
9673 }
9674 {
9675 if (temp4)
9676 delete arg4;
9677 }
9678 return resultobj;
9679 fail:
9680 {
9681 if (temp2)
9682 delete arg2;
9683 }
9684 {
9685 if (temp3)
9686 delete arg3;
9687 }
9688 {
9689 if (temp4)
9690 delete arg4;
9691 }
9692 return NULL;
9693 }
9694
9695
9696 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9697 PyObject *resultobj = 0;
9698 wxFSFile *arg1 = (wxFSFile *) 0 ;
9699 void *argp1 = 0 ;
9700 int res1 = 0 ;
9701 PyObject *swig_obj[1] ;
9702
9703 if (!args) SWIG_fail;
9704 swig_obj[0] = args;
9705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9706 if (!SWIG_IsOK(res1)) {
9707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9708 }
9709 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9710 {
9711 PyThreadState* __tstate = wxPyBeginAllowThreads();
9712 delete arg1;
9713
9714 wxPyEndAllowThreads(__tstate);
9715 if (PyErr_Occurred()) SWIG_fail;
9716 }
9717 resultobj = SWIG_Py_Void();
9718 return resultobj;
9719 fail:
9720 return NULL;
9721 }
9722
9723
9724 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9725 PyObject *resultobj = 0;
9726 wxFSFile *arg1 = (wxFSFile *) 0 ;
9727 wxInputStream *result = 0 ;
9728 void *argp1 = 0 ;
9729 int res1 = 0 ;
9730 PyObject *swig_obj[1] ;
9731
9732 if (!args) SWIG_fail;
9733 swig_obj[0] = args;
9734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9735 if (!SWIG_IsOK(res1)) {
9736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9737 }
9738 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9739 {
9740 PyThreadState* __tstate = wxPyBeginAllowThreads();
9741 result = (wxInputStream *)(arg1)->GetStream();
9742 wxPyEndAllowThreads(__tstate);
9743 if (PyErr_Occurred()) SWIG_fail;
9744 }
9745 {
9746 wxPyInputStream * _ptr = NULL;
9747
9748 if (result) {
9749 _ptr = new wxPyInputStream(result);
9750 }
9751 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9752 }
9753 return resultobj;
9754 fail:
9755 return NULL;
9756 }
9757
9758
9759 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9760 PyObject *resultobj = 0;
9761 wxFSFile *arg1 = (wxFSFile *) 0 ;
9762 wxString *result = 0 ;
9763 void *argp1 = 0 ;
9764 int res1 = 0 ;
9765 PyObject *swig_obj[1] ;
9766
9767 if (!args) SWIG_fail;
9768 swig_obj[0] = args;
9769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9770 if (!SWIG_IsOK(res1)) {
9771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9772 }
9773 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9774 {
9775 PyThreadState* __tstate = wxPyBeginAllowThreads();
9776 {
9777 wxString const &_result_ref = (arg1)->GetMimeType();
9778 result = (wxString *) &_result_ref;
9779 }
9780 wxPyEndAllowThreads(__tstate);
9781 if (PyErr_Occurred()) SWIG_fail;
9782 }
9783 {
9784 #if wxUSE_UNICODE
9785 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9786 #else
9787 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9788 #endif
9789 }
9790 return resultobj;
9791 fail:
9792 return NULL;
9793 }
9794
9795
9796 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9797 PyObject *resultobj = 0;
9798 wxFSFile *arg1 = (wxFSFile *) 0 ;
9799 wxString *result = 0 ;
9800 void *argp1 = 0 ;
9801 int res1 = 0 ;
9802 PyObject *swig_obj[1] ;
9803
9804 if (!args) SWIG_fail;
9805 swig_obj[0] = args;
9806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9807 if (!SWIG_IsOK(res1)) {
9808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9809 }
9810 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9811 {
9812 PyThreadState* __tstate = wxPyBeginAllowThreads();
9813 {
9814 wxString const &_result_ref = (arg1)->GetLocation();
9815 result = (wxString *) &_result_ref;
9816 }
9817 wxPyEndAllowThreads(__tstate);
9818 if (PyErr_Occurred()) SWIG_fail;
9819 }
9820 {
9821 #if wxUSE_UNICODE
9822 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9823 #else
9824 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9825 #endif
9826 }
9827 return resultobj;
9828 fail:
9829 return NULL;
9830 }
9831
9832
9833 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9834 PyObject *resultobj = 0;
9835 wxFSFile *arg1 = (wxFSFile *) 0 ;
9836 wxString *result = 0 ;
9837 void *argp1 = 0 ;
9838 int res1 = 0 ;
9839 PyObject *swig_obj[1] ;
9840
9841 if (!args) SWIG_fail;
9842 swig_obj[0] = args;
9843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9844 if (!SWIG_IsOK(res1)) {
9845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9846 }
9847 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9848 {
9849 PyThreadState* __tstate = wxPyBeginAllowThreads();
9850 {
9851 wxString const &_result_ref = (arg1)->GetAnchor();
9852 result = (wxString *) &_result_ref;
9853 }
9854 wxPyEndAllowThreads(__tstate);
9855 if (PyErr_Occurred()) SWIG_fail;
9856 }
9857 {
9858 #if wxUSE_UNICODE
9859 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9860 #else
9861 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9862 #endif
9863 }
9864 return resultobj;
9865 fail:
9866 return NULL;
9867 }
9868
9869
9870 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9871 PyObject *resultobj = 0;
9872 wxFSFile *arg1 = (wxFSFile *) 0 ;
9873 wxDateTime result;
9874 void *argp1 = 0 ;
9875 int res1 = 0 ;
9876 PyObject *swig_obj[1] ;
9877
9878 if (!args) SWIG_fail;
9879 swig_obj[0] = args;
9880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9881 if (!SWIG_IsOK(res1)) {
9882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9883 }
9884 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9885 {
9886 PyThreadState* __tstate = wxPyBeginAllowThreads();
9887 result = (arg1)->GetModificationTime();
9888 wxPyEndAllowThreads(__tstate);
9889 if (PyErr_Occurred()) SWIG_fail;
9890 }
9891 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9892 return resultobj;
9893 fail:
9894 return NULL;
9895 }
9896
9897
9898 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9899 PyObject *obj;
9900 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9901 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9902 return SWIG_Py_Void();
9903 }
9904
9905 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9906 return SWIG_Python_InitShadowInstance(args);
9907 }
9908
9909 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9910 PyObject *resultobj = 0;
9911 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9912 void *argp1 = 0 ;
9913 int res1 = 0 ;
9914 PyObject *swig_obj[1] ;
9915
9916 if (!args) SWIG_fail;
9917 swig_obj[0] = args;
9918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9919 if (!SWIG_IsOK(res1)) {
9920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9921 }
9922 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9923 {
9924 PyThreadState* __tstate = wxPyBeginAllowThreads();
9925 delete arg1;
9926
9927 wxPyEndAllowThreads(__tstate);
9928 if (PyErr_Occurred()) SWIG_fail;
9929 }
9930 resultobj = SWIG_Py_Void();
9931 return resultobj;
9932 fail:
9933 return NULL;
9934 }
9935
9936
9937 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9938 PyObject *obj;
9939 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9940 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9941 return SWIG_Py_Void();
9942 }
9943
9944 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9945 PyObject *resultobj = 0;
9946 wxPyFileSystemHandler *result = 0 ;
9947
9948 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9949 {
9950 PyThreadState* __tstate = wxPyBeginAllowThreads();
9951 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9952 wxPyEndAllowThreads(__tstate);
9953 if (PyErr_Occurred()) SWIG_fail;
9954 }
9955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9956 return resultobj;
9957 fail:
9958 return NULL;
9959 }
9960
9961
9962 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9963 PyObject *resultobj = 0;
9964 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9965 PyObject *arg2 = (PyObject *) 0 ;
9966 PyObject *arg3 = (PyObject *) 0 ;
9967 void *argp1 = 0 ;
9968 int res1 = 0 ;
9969 PyObject * obj0 = 0 ;
9970 PyObject * obj1 = 0 ;
9971 PyObject * obj2 = 0 ;
9972 char * kwnames[] = {
9973 (char *) "self",(char *) "self",(char *) "_class", NULL
9974 };
9975
9976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9978 if (!SWIG_IsOK(res1)) {
9979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9980 }
9981 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9982 arg2 = obj1;
9983 arg3 = obj2;
9984 {
9985 PyThreadState* __tstate = wxPyBeginAllowThreads();
9986 (arg1)->_setCallbackInfo(arg2,arg3);
9987 wxPyEndAllowThreads(__tstate);
9988 if (PyErr_Occurred()) SWIG_fail;
9989 }
9990 resultobj = SWIG_Py_Void();
9991 return resultobj;
9992 fail:
9993 return NULL;
9994 }
9995
9996
9997 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9998 PyObject *resultobj = 0;
9999 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10000 wxString *arg2 = 0 ;
10001 bool result;
10002 void *argp1 = 0 ;
10003 int res1 = 0 ;
10004 bool temp2 = false ;
10005 PyObject * obj0 = 0 ;
10006 PyObject * obj1 = 0 ;
10007 char * kwnames[] = {
10008 (char *) "self",(char *) "location", NULL
10009 };
10010
10011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10013 if (!SWIG_IsOK(res1)) {
10014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10015 }
10016 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10017 {
10018 arg2 = wxString_in_helper(obj1);
10019 if (arg2 == NULL) SWIG_fail;
10020 temp2 = true;
10021 }
10022 {
10023 PyThreadState* __tstate = wxPyBeginAllowThreads();
10024 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10025 wxPyEndAllowThreads(__tstate);
10026 if (PyErr_Occurred()) SWIG_fail;
10027 }
10028 {
10029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10030 }
10031 {
10032 if (temp2)
10033 delete arg2;
10034 }
10035 return resultobj;
10036 fail:
10037 {
10038 if (temp2)
10039 delete arg2;
10040 }
10041 return NULL;
10042 }
10043
10044
10045 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10046 PyObject *resultobj = 0;
10047 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10048 wxFileSystem *arg2 = 0 ;
10049 wxString *arg3 = 0 ;
10050 wxFSFile *result = 0 ;
10051 void *argp1 = 0 ;
10052 int res1 = 0 ;
10053 void *argp2 = 0 ;
10054 int res2 = 0 ;
10055 bool temp3 = false ;
10056 PyObject * obj0 = 0 ;
10057 PyObject * obj1 = 0 ;
10058 PyObject * obj2 = 0 ;
10059 char * kwnames[] = {
10060 (char *) "self",(char *) "fs",(char *) "location", NULL
10061 };
10062
10063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10065 if (!SWIG_IsOK(res1)) {
10066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10067 }
10068 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10069 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10070 if (!SWIG_IsOK(res2)) {
10071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10072 }
10073 if (!argp2) {
10074 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10075 }
10076 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10077 {
10078 arg3 = wxString_in_helper(obj2);
10079 if (arg3 == NULL) SWIG_fail;
10080 temp3 = true;
10081 }
10082 {
10083 PyThreadState* __tstate = wxPyBeginAllowThreads();
10084 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10085 wxPyEndAllowThreads(__tstate);
10086 if (PyErr_Occurred()) SWIG_fail;
10087 }
10088 {
10089 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10090 }
10091 {
10092 if (temp3)
10093 delete arg3;
10094 }
10095 return resultobj;
10096 fail:
10097 {
10098 if (temp3)
10099 delete arg3;
10100 }
10101 return NULL;
10102 }
10103
10104
10105 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10106 PyObject *resultobj = 0;
10107 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10108 wxString *arg2 = 0 ;
10109 int arg3 = (int) 0 ;
10110 wxString result;
10111 void *argp1 = 0 ;
10112 int res1 = 0 ;
10113 bool temp2 = false ;
10114 int val3 ;
10115 int ecode3 = 0 ;
10116 PyObject * obj0 = 0 ;
10117 PyObject * obj1 = 0 ;
10118 PyObject * obj2 = 0 ;
10119 char * kwnames[] = {
10120 (char *) "self",(char *) "spec",(char *) "flags", NULL
10121 };
10122
10123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10125 if (!SWIG_IsOK(res1)) {
10126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10127 }
10128 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10129 {
10130 arg2 = wxString_in_helper(obj1);
10131 if (arg2 == NULL) SWIG_fail;
10132 temp2 = true;
10133 }
10134 if (obj2) {
10135 ecode3 = SWIG_AsVal_int(obj2, &val3);
10136 if (!SWIG_IsOK(ecode3)) {
10137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10138 }
10139 arg3 = static_cast< int >(val3);
10140 }
10141 {
10142 PyThreadState* __tstate = wxPyBeginAllowThreads();
10143 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10144 wxPyEndAllowThreads(__tstate);
10145 if (PyErr_Occurred()) SWIG_fail;
10146 }
10147 {
10148 #if wxUSE_UNICODE
10149 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10150 #else
10151 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10152 #endif
10153 }
10154 {
10155 if (temp2)
10156 delete arg2;
10157 }
10158 return resultobj;
10159 fail:
10160 {
10161 if (temp2)
10162 delete arg2;
10163 }
10164 return NULL;
10165 }
10166
10167
10168 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10169 PyObject *resultobj = 0;
10170 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10171 wxString result;
10172 void *argp1 = 0 ;
10173 int res1 = 0 ;
10174 PyObject *swig_obj[1] ;
10175
10176 if (!args) SWIG_fail;
10177 swig_obj[0] = args;
10178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10179 if (!SWIG_IsOK(res1)) {
10180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10181 }
10182 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10183 {
10184 PyThreadState* __tstate = wxPyBeginAllowThreads();
10185 result = (arg1)->FindNext();
10186 wxPyEndAllowThreads(__tstate);
10187 if (PyErr_Occurred()) SWIG_fail;
10188 }
10189 {
10190 #if wxUSE_UNICODE
10191 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10192 #else
10193 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10194 #endif
10195 }
10196 return resultobj;
10197 fail:
10198 return NULL;
10199 }
10200
10201
10202 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10203 PyObject *resultobj = 0;
10204 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10205 wxString *arg2 = 0 ;
10206 wxString result;
10207 void *argp1 = 0 ;
10208 int res1 = 0 ;
10209 bool temp2 = false ;
10210 PyObject * obj0 = 0 ;
10211 PyObject * obj1 = 0 ;
10212 char * kwnames[] = {
10213 (char *) "self",(char *) "location", NULL
10214 };
10215
10216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10218 if (!SWIG_IsOK(res1)) {
10219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10220 }
10221 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10222 {
10223 arg2 = wxString_in_helper(obj1);
10224 if (arg2 == NULL) SWIG_fail;
10225 temp2 = true;
10226 }
10227 {
10228 PyThreadState* __tstate = wxPyBeginAllowThreads();
10229 result = (arg1)->GetProtocol((wxString const &)*arg2);
10230 wxPyEndAllowThreads(__tstate);
10231 if (PyErr_Occurred()) SWIG_fail;
10232 }
10233 {
10234 #if wxUSE_UNICODE
10235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10236 #else
10237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10238 #endif
10239 }
10240 {
10241 if (temp2)
10242 delete arg2;
10243 }
10244 return resultobj;
10245 fail:
10246 {
10247 if (temp2)
10248 delete arg2;
10249 }
10250 return NULL;
10251 }
10252
10253
10254 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10255 PyObject *resultobj = 0;
10256 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10257 wxString *arg2 = 0 ;
10258 wxString result;
10259 void *argp1 = 0 ;
10260 int res1 = 0 ;
10261 bool temp2 = false ;
10262 PyObject * obj0 = 0 ;
10263 PyObject * obj1 = 0 ;
10264 char * kwnames[] = {
10265 (char *) "self",(char *) "location", NULL
10266 };
10267
10268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10270 if (!SWIG_IsOK(res1)) {
10271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10272 }
10273 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10274 {
10275 arg2 = wxString_in_helper(obj1);
10276 if (arg2 == NULL) SWIG_fail;
10277 temp2 = true;
10278 }
10279 {
10280 PyThreadState* __tstate = wxPyBeginAllowThreads();
10281 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10282 wxPyEndAllowThreads(__tstate);
10283 if (PyErr_Occurred()) SWIG_fail;
10284 }
10285 {
10286 #if wxUSE_UNICODE
10287 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10288 #else
10289 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10290 #endif
10291 }
10292 {
10293 if (temp2)
10294 delete arg2;
10295 }
10296 return resultobj;
10297 fail:
10298 {
10299 if (temp2)
10300 delete arg2;
10301 }
10302 return NULL;
10303 }
10304
10305
10306 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10307 PyObject *resultobj = 0;
10308 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10309 wxString *arg2 = 0 ;
10310 wxString result;
10311 void *argp1 = 0 ;
10312 int res1 = 0 ;
10313 bool temp2 = false ;
10314 PyObject * obj0 = 0 ;
10315 PyObject * obj1 = 0 ;
10316 char * kwnames[] = {
10317 (char *) "self",(char *) "location", NULL
10318 };
10319
10320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10322 if (!SWIG_IsOK(res1)) {
10323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10324 }
10325 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10326 {
10327 arg2 = wxString_in_helper(obj1);
10328 if (arg2 == NULL) SWIG_fail;
10329 temp2 = true;
10330 }
10331 {
10332 PyThreadState* __tstate = wxPyBeginAllowThreads();
10333 result = (arg1)->GetAnchor((wxString const &)*arg2);
10334 wxPyEndAllowThreads(__tstate);
10335 if (PyErr_Occurred()) SWIG_fail;
10336 }
10337 {
10338 #if wxUSE_UNICODE
10339 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10340 #else
10341 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10342 #endif
10343 }
10344 {
10345 if (temp2)
10346 delete arg2;
10347 }
10348 return resultobj;
10349 fail:
10350 {
10351 if (temp2)
10352 delete arg2;
10353 }
10354 return NULL;
10355 }
10356
10357
10358 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10359 PyObject *resultobj = 0;
10360 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10361 wxString *arg2 = 0 ;
10362 wxString result;
10363 void *argp1 = 0 ;
10364 int res1 = 0 ;
10365 bool temp2 = false ;
10366 PyObject * obj0 = 0 ;
10367 PyObject * obj1 = 0 ;
10368 char * kwnames[] = {
10369 (char *) "self",(char *) "location", NULL
10370 };
10371
10372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10374 if (!SWIG_IsOK(res1)) {
10375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10376 }
10377 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10378 {
10379 arg2 = wxString_in_helper(obj1);
10380 if (arg2 == NULL) SWIG_fail;
10381 temp2 = true;
10382 }
10383 {
10384 PyThreadState* __tstate = wxPyBeginAllowThreads();
10385 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10386 wxPyEndAllowThreads(__tstate);
10387 if (PyErr_Occurred()) SWIG_fail;
10388 }
10389 {
10390 #if wxUSE_UNICODE
10391 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10392 #else
10393 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10394 #endif
10395 }
10396 {
10397 if (temp2)
10398 delete arg2;
10399 }
10400 return resultobj;
10401 fail:
10402 {
10403 if (temp2)
10404 delete arg2;
10405 }
10406 return NULL;
10407 }
10408
10409
10410 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10411 PyObject *resultobj = 0;
10412 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10413 wxString *arg2 = 0 ;
10414 wxString result;
10415 void *argp1 = 0 ;
10416 int res1 = 0 ;
10417 bool temp2 = false ;
10418 PyObject * obj0 = 0 ;
10419 PyObject * obj1 = 0 ;
10420 char * kwnames[] = {
10421 (char *) "self",(char *) "location", NULL
10422 };
10423
10424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10426 if (!SWIG_IsOK(res1)) {
10427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10428 }
10429 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10430 {
10431 arg2 = wxString_in_helper(obj1);
10432 if (arg2 == NULL) SWIG_fail;
10433 temp2 = true;
10434 }
10435 {
10436 PyThreadState* __tstate = wxPyBeginAllowThreads();
10437 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10438 wxPyEndAllowThreads(__tstate);
10439 if (PyErr_Occurred()) SWIG_fail;
10440 }
10441 {
10442 #if wxUSE_UNICODE
10443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10444 #else
10445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10446 #endif
10447 }
10448 {
10449 if (temp2)
10450 delete arg2;
10451 }
10452 return resultobj;
10453 fail:
10454 {
10455 if (temp2)
10456 delete arg2;
10457 }
10458 return NULL;
10459 }
10460
10461
10462 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10463 PyObject *obj;
10464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10465 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10466 return SWIG_Py_Void();
10467 }
10468
10469 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10470 return SWIG_Python_InitShadowInstance(args);
10471 }
10472
10473 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10474 PyObject *resultobj = 0;
10475 wxFileSystem *result = 0 ;
10476
10477 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10478 {
10479 PyThreadState* __tstate = wxPyBeginAllowThreads();
10480 result = (wxFileSystem *)new wxFileSystem();
10481 wxPyEndAllowThreads(__tstate);
10482 if (PyErr_Occurred()) SWIG_fail;
10483 }
10484 {
10485 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10486 }
10487 return resultobj;
10488 fail:
10489 return NULL;
10490 }
10491
10492
10493 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10494 PyObject *resultobj = 0;
10495 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10496 void *argp1 = 0 ;
10497 int res1 = 0 ;
10498 PyObject *swig_obj[1] ;
10499
10500 if (!args) SWIG_fail;
10501 swig_obj[0] = args;
10502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10503 if (!SWIG_IsOK(res1)) {
10504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10505 }
10506 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10507 {
10508 PyThreadState* __tstate = wxPyBeginAllowThreads();
10509 delete arg1;
10510
10511 wxPyEndAllowThreads(__tstate);
10512 if (PyErr_Occurred()) SWIG_fail;
10513 }
10514 resultobj = SWIG_Py_Void();
10515 return resultobj;
10516 fail:
10517 return NULL;
10518 }
10519
10520
10521 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10522 PyObject *resultobj = 0;
10523 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10524 wxString *arg2 = 0 ;
10525 bool arg3 = (bool) false ;
10526 void *argp1 = 0 ;
10527 int res1 = 0 ;
10528 bool temp2 = false ;
10529 bool val3 ;
10530 int ecode3 = 0 ;
10531 PyObject * obj0 = 0 ;
10532 PyObject * obj1 = 0 ;
10533 PyObject * obj2 = 0 ;
10534 char * kwnames[] = {
10535 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10536 };
10537
10538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10540 if (!SWIG_IsOK(res1)) {
10541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10542 }
10543 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10544 {
10545 arg2 = wxString_in_helper(obj1);
10546 if (arg2 == NULL) SWIG_fail;
10547 temp2 = true;
10548 }
10549 if (obj2) {
10550 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10551 if (!SWIG_IsOK(ecode3)) {
10552 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10553 }
10554 arg3 = static_cast< bool >(val3);
10555 }
10556 {
10557 PyThreadState* __tstate = wxPyBeginAllowThreads();
10558 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10559 wxPyEndAllowThreads(__tstate);
10560 if (PyErr_Occurred()) SWIG_fail;
10561 }
10562 resultobj = SWIG_Py_Void();
10563 {
10564 if (temp2)
10565 delete arg2;
10566 }
10567 return resultobj;
10568 fail:
10569 {
10570 if (temp2)
10571 delete arg2;
10572 }
10573 return NULL;
10574 }
10575
10576
10577 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10578 PyObject *resultobj = 0;
10579 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10580 wxString result;
10581 void *argp1 = 0 ;
10582 int res1 = 0 ;
10583 PyObject *swig_obj[1] ;
10584
10585 if (!args) SWIG_fail;
10586 swig_obj[0] = args;
10587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10588 if (!SWIG_IsOK(res1)) {
10589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10590 }
10591 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10592 {
10593 PyThreadState* __tstate = wxPyBeginAllowThreads();
10594 result = (arg1)->GetPath();
10595 wxPyEndAllowThreads(__tstate);
10596 if (PyErr_Occurred()) SWIG_fail;
10597 }
10598 {
10599 #if wxUSE_UNICODE
10600 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10601 #else
10602 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10603 #endif
10604 }
10605 return resultobj;
10606 fail:
10607 return NULL;
10608 }
10609
10610
10611 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10612 PyObject *resultobj = 0;
10613 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10614 wxString *arg2 = 0 ;
10615 wxFSFile *result = 0 ;
10616 void *argp1 = 0 ;
10617 int res1 = 0 ;
10618 bool temp2 = false ;
10619 PyObject * obj0 = 0 ;
10620 PyObject * obj1 = 0 ;
10621 char * kwnames[] = {
10622 (char *) "self",(char *) "location", NULL
10623 };
10624
10625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10627 if (!SWIG_IsOK(res1)) {
10628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10629 }
10630 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10631 {
10632 arg2 = wxString_in_helper(obj1);
10633 if (arg2 == NULL) SWIG_fail;
10634 temp2 = true;
10635 }
10636 {
10637 PyThreadState* __tstate = wxPyBeginAllowThreads();
10638 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10639 wxPyEndAllowThreads(__tstate);
10640 if (PyErr_Occurred()) SWIG_fail;
10641 }
10642 {
10643 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10644 }
10645 {
10646 if (temp2)
10647 delete arg2;
10648 }
10649 return resultobj;
10650 fail:
10651 {
10652 if (temp2)
10653 delete arg2;
10654 }
10655 return NULL;
10656 }
10657
10658
10659 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10660 PyObject *resultobj = 0;
10661 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10662 wxString *arg2 = 0 ;
10663 int arg3 = (int) 0 ;
10664 wxString result;
10665 void *argp1 = 0 ;
10666 int res1 = 0 ;
10667 bool temp2 = false ;
10668 int val3 ;
10669 int ecode3 = 0 ;
10670 PyObject * obj0 = 0 ;
10671 PyObject * obj1 = 0 ;
10672 PyObject * obj2 = 0 ;
10673 char * kwnames[] = {
10674 (char *) "self",(char *) "spec",(char *) "flags", NULL
10675 };
10676
10677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10679 if (!SWIG_IsOK(res1)) {
10680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10681 }
10682 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10683 {
10684 arg2 = wxString_in_helper(obj1);
10685 if (arg2 == NULL) SWIG_fail;
10686 temp2 = true;
10687 }
10688 if (obj2) {
10689 ecode3 = SWIG_AsVal_int(obj2, &val3);
10690 if (!SWIG_IsOK(ecode3)) {
10691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10692 }
10693 arg3 = static_cast< int >(val3);
10694 }
10695 {
10696 PyThreadState* __tstate = wxPyBeginAllowThreads();
10697 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10698 wxPyEndAllowThreads(__tstate);
10699 if (PyErr_Occurred()) SWIG_fail;
10700 }
10701 {
10702 #if wxUSE_UNICODE
10703 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10704 #else
10705 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10706 #endif
10707 }
10708 {
10709 if (temp2)
10710 delete arg2;
10711 }
10712 return resultobj;
10713 fail:
10714 {
10715 if (temp2)
10716 delete arg2;
10717 }
10718 return NULL;
10719 }
10720
10721
10722 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10723 PyObject *resultobj = 0;
10724 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10725 wxString result;
10726 void *argp1 = 0 ;
10727 int res1 = 0 ;
10728 PyObject *swig_obj[1] ;
10729
10730 if (!args) SWIG_fail;
10731 swig_obj[0] = args;
10732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10733 if (!SWIG_IsOK(res1)) {
10734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10735 }
10736 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10737 {
10738 PyThreadState* __tstate = wxPyBeginAllowThreads();
10739 result = (arg1)->FindNext();
10740 wxPyEndAllowThreads(__tstate);
10741 if (PyErr_Occurred()) SWIG_fail;
10742 }
10743 {
10744 #if wxUSE_UNICODE
10745 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10746 #else
10747 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10748 #endif
10749 }
10750 return resultobj;
10751 fail:
10752 return NULL;
10753 }
10754
10755
10756 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10757 PyObject *resultobj = 0;
10758 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10759 int res1 = 0 ;
10760 PyObject * obj0 = 0 ;
10761 char * kwnames[] = {
10762 (char *) "handler", NULL
10763 };
10764
10765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10766 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10767 if (!SWIG_IsOK(res1)) {
10768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10769 }
10770 {
10771 PyThreadState* __tstate = wxPyBeginAllowThreads();
10772 wxFileSystem::AddHandler(arg1);
10773 wxPyEndAllowThreads(__tstate);
10774 if (PyErr_Occurred()) SWIG_fail;
10775 }
10776 resultobj = SWIG_Py_Void();
10777 return resultobj;
10778 fail:
10779 return NULL;
10780 }
10781
10782
10783 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10784 PyObject *resultobj = 0;
10785
10786 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10787 {
10788 PyThreadState* __tstate = wxPyBeginAllowThreads();
10789 wxFileSystem::CleanUpHandlers();
10790 wxPyEndAllowThreads(__tstate);
10791 if (PyErr_Occurred()) SWIG_fail;
10792 }
10793 resultobj = SWIG_Py_Void();
10794 return resultobj;
10795 fail:
10796 return NULL;
10797 }
10798
10799
10800 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10801 PyObject *resultobj = 0;
10802 wxString *arg1 = 0 ;
10803 wxString result;
10804 bool temp1 = false ;
10805 PyObject * obj0 = 0 ;
10806 char * kwnames[] = {
10807 (char *) "filename", NULL
10808 };
10809
10810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10811 {
10812 arg1 = wxString_in_helper(obj0);
10813 if (arg1 == NULL) SWIG_fail;
10814 temp1 = true;
10815 }
10816 {
10817 PyThreadState* __tstate = wxPyBeginAllowThreads();
10818 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10819 wxPyEndAllowThreads(__tstate);
10820 if (PyErr_Occurred()) SWIG_fail;
10821 }
10822 {
10823 #if wxUSE_UNICODE
10824 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10825 #else
10826 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10827 #endif
10828 }
10829 {
10830 if (temp1)
10831 delete arg1;
10832 }
10833 return resultobj;
10834 fail:
10835 {
10836 if (temp1)
10837 delete arg1;
10838 }
10839 return NULL;
10840 }
10841
10842
10843 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10844 PyObject *resultobj = 0;
10845 wxString *arg1 = 0 ;
10846 wxString result;
10847 bool temp1 = false ;
10848 PyObject * obj0 = 0 ;
10849 char * kwnames[] = {
10850 (char *) "url", NULL
10851 };
10852
10853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10854 {
10855 arg1 = wxString_in_helper(obj0);
10856 if (arg1 == NULL) SWIG_fail;
10857 temp1 = true;
10858 }
10859 {
10860 PyThreadState* __tstate = wxPyBeginAllowThreads();
10861 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10862 wxPyEndAllowThreads(__tstate);
10863 if (PyErr_Occurred()) SWIG_fail;
10864 }
10865 {
10866 #if wxUSE_UNICODE
10867 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10868 #else
10869 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10870 #endif
10871 }
10872 {
10873 if (temp1)
10874 delete arg1;
10875 }
10876 return resultobj;
10877 fail:
10878 {
10879 if (temp1)
10880 delete arg1;
10881 }
10882 return NULL;
10883 }
10884
10885
10886 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10887 PyObject *obj;
10888 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10889 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10890 return SWIG_Py_Void();
10891 }
10892
10893 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10894 return SWIG_Python_InitShadowInstance(args);
10895 }
10896
10897 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10898 PyObject *resultobj = 0;
10899 wxInternetFSHandler *result = 0 ;
10900
10901 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10902 {
10903 PyThreadState* __tstate = wxPyBeginAllowThreads();
10904 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10905 wxPyEndAllowThreads(__tstate);
10906 if (PyErr_Occurred()) SWIG_fail;
10907 }
10908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10909 return resultobj;
10910 fail:
10911 return NULL;
10912 }
10913
10914
10915 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10916 PyObject *resultobj = 0;
10917 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10918 wxString *arg2 = 0 ;
10919 bool result;
10920 void *argp1 = 0 ;
10921 int res1 = 0 ;
10922 bool temp2 = false ;
10923 PyObject * obj0 = 0 ;
10924 PyObject * obj1 = 0 ;
10925 char * kwnames[] = {
10926 (char *) "self",(char *) "location", NULL
10927 };
10928
10929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10931 if (!SWIG_IsOK(res1)) {
10932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10933 }
10934 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10935 {
10936 arg2 = wxString_in_helper(obj1);
10937 if (arg2 == NULL) SWIG_fail;
10938 temp2 = true;
10939 }
10940 {
10941 PyThreadState* __tstate = wxPyBeginAllowThreads();
10942 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10943 wxPyEndAllowThreads(__tstate);
10944 if (PyErr_Occurred()) SWIG_fail;
10945 }
10946 {
10947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10948 }
10949 {
10950 if (temp2)
10951 delete arg2;
10952 }
10953 return resultobj;
10954 fail:
10955 {
10956 if (temp2)
10957 delete arg2;
10958 }
10959 return NULL;
10960 }
10961
10962
10963 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10964 PyObject *resultobj = 0;
10965 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10966 wxFileSystem *arg2 = 0 ;
10967 wxString *arg3 = 0 ;
10968 wxFSFile *result = 0 ;
10969 void *argp1 = 0 ;
10970 int res1 = 0 ;
10971 void *argp2 = 0 ;
10972 int res2 = 0 ;
10973 bool temp3 = false ;
10974 PyObject * obj0 = 0 ;
10975 PyObject * obj1 = 0 ;
10976 PyObject * obj2 = 0 ;
10977 char * kwnames[] = {
10978 (char *) "self",(char *) "fs",(char *) "location", NULL
10979 };
10980
10981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10983 if (!SWIG_IsOK(res1)) {
10984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10985 }
10986 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10987 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10988 if (!SWIG_IsOK(res2)) {
10989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10990 }
10991 if (!argp2) {
10992 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10993 }
10994 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10995 {
10996 arg3 = wxString_in_helper(obj2);
10997 if (arg3 == NULL) SWIG_fail;
10998 temp3 = true;
10999 }
11000 {
11001 PyThreadState* __tstate = wxPyBeginAllowThreads();
11002 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11003 wxPyEndAllowThreads(__tstate);
11004 if (PyErr_Occurred()) SWIG_fail;
11005 }
11006 {
11007 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11008 }
11009 {
11010 if (temp3)
11011 delete arg3;
11012 }
11013 return resultobj;
11014 fail:
11015 {
11016 if (temp3)
11017 delete arg3;
11018 }
11019 return NULL;
11020 }
11021
11022
11023 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11024 PyObject *obj;
11025 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11026 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11027 return SWIG_Py_Void();
11028 }
11029
11030 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11031 return SWIG_Python_InitShadowInstance(args);
11032 }
11033
11034 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11035 PyObject *resultobj = 0;
11036 wxZipFSHandler *result = 0 ;
11037
11038 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11039 {
11040 PyThreadState* __tstate = wxPyBeginAllowThreads();
11041 result = (wxZipFSHandler *)new wxZipFSHandler();
11042 wxPyEndAllowThreads(__tstate);
11043 if (PyErr_Occurred()) SWIG_fail;
11044 }
11045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11046 return resultobj;
11047 fail:
11048 return NULL;
11049 }
11050
11051
11052 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11053 PyObject *resultobj = 0;
11054 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11055 wxString *arg2 = 0 ;
11056 bool result;
11057 void *argp1 = 0 ;
11058 int res1 = 0 ;
11059 bool temp2 = false ;
11060 PyObject * obj0 = 0 ;
11061 PyObject * obj1 = 0 ;
11062 char * kwnames[] = {
11063 (char *) "self",(char *) "location", NULL
11064 };
11065
11066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11068 if (!SWIG_IsOK(res1)) {
11069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11070 }
11071 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11072 {
11073 arg2 = wxString_in_helper(obj1);
11074 if (arg2 == NULL) SWIG_fail;
11075 temp2 = true;
11076 }
11077 {
11078 PyThreadState* __tstate = wxPyBeginAllowThreads();
11079 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 {
11084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11085 }
11086 {
11087 if (temp2)
11088 delete arg2;
11089 }
11090 return resultobj;
11091 fail:
11092 {
11093 if (temp2)
11094 delete arg2;
11095 }
11096 return NULL;
11097 }
11098
11099
11100 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11101 PyObject *resultobj = 0;
11102 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11103 wxFileSystem *arg2 = 0 ;
11104 wxString *arg3 = 0 ;
11105 wxFSFile *result = 0 ;
11106 void *argp1 = 0 ;
11107 int res1 = 0 ;
11108 void *argp2 = 0 ;
11109 int res2 = 0 ;
11110 bool temp3 = false ;
11111 PyObject * obj0 = 0 ;
11112 PyObject * obj1 = 0 ;
11113 PyObject * obj2 = 0 ;
11114 char * kwnames[] = {
11115 (char *) "self",(char *) "fs",(char *) "location", NULL
11116 };
11117
11118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11120 if (!SWIG_IsOK(res1)) {
11121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11122 }
11123 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11124 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11125 if (!SWIG_IsOK(res2)) {
11126 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11127 }
11128 if (!argp2) {
11129 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11130 }
11131 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11132 {
11133 arg3 = wxString_in_helper(obj2);
11134 if (arg3 == NULL) SWIG_fail;
11135 temp3 = true;
11136 }
11137 {
11138 PyThreadState* __tstate = wxPyBeginAllowThreads();
11139 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11140 wxPyEndAllowThreads(__tstate);
11141 if (PyErr_Occurred()) SWIG_fail;
11142 }
11143 {
11144 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11145 }
11146 {
11147 if (temp3)
11148 delete arg3;
11149 }
11150 return resultobj;
11151 fail:
11152 {
11153 if (temp3)
11154 delete arg3;
11155 }
11156 return NULL;
11157 }
11158
11159
11160 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11161 PyObject *resultobj = 0;
11162 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11163 wxString *arg2 = 0 ;
11164 int arg3 = (int) 0 ;
11165 wxString result;
11166 void *argp1 = 0 ;
11167 int res1 = 0 ;
11168 bool temp2 = false ;
11169 int val3 ;
11170 int ecode3 = 0 ;
11171 PyObject * obj0 = 0 ;
11172 PyObject * obj1 = 0 ;
11173 PyObject * obj2 = 0 ;
11174 char * kwnames[] = {
11175 (char *) "self",(char *) "spec",(char *) "flags", NULL
11176 };
11177
11178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11180 if (!SWIG_IsOK(res1)) {
11181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11182 }
11183 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11184 {
11185 arg2 = wxString_in_helper(obj1);
11186 if (arg2 == NULL) SWIG_fail;
11187 temp2 = true;
11188 }
11189 if (obj2) {
11190 ecode3 = SWIG_AsVal_int(obj2, &val3);
11191 if (!SWIG_IsOK(ecode3)) {
11192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11193 }
11194 arg3 = static_cast< int >(val3);
11195 }
11196 {
11197 PyThreadState* __tstate = wxPyBeginAllowThreads();
11198 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11199 wxPyEndAllowThreads(__tstate);
11200 if (PyErr_Occurred()) SWIG_fail;
11201 }
11202 {
11203 #if wxUSE_UNICODE
11204 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11205 #else
11206 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11207 #endif
11208 }
11209 {
11210 if (temp2)
11211 delete arg2;
11212 }
11213 return resultobj;
11214 fail:
11215 {
11216 if (temp2)
11217 delete arg2;
11218 }
11219 return NULL;
11220 }
11221
11222
11223 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11224 PyObject *resultobj = 0;
11225 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11226 wxString result;
11227 void *argp1 = 0 ;
11228 int res1 = 0 ;
11229 PyObject *swig_obj[1] ;
11230
11231 if (!args) SWIG_fail;
11232 swig_obj[0] = args;
11233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11234 if (!SWIG_IsOK(res1)) {
11235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11236 }
11237 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11238 {
11239 PyThreadState* __tstate = wxPyBeginAllowThreads();
11240 result = (arg1)->FindNext();
11241 wxPyEndAllowThreads(__tstate);
11242 if (PyErr_Occurred()) SWIG_fail;
11243 }
11244 {
11245 #if wxUSE_UNICODE
11246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11247 #else
11248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11249 #endif
11250 }
11251 return resultobj;
11252 fail:
11253 return NULL;
11254 }
11255
11256
11257 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11258 PyObject *obj;
11259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11260 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11261 return SWIG_Py_Void();
11262 }
11263
11264 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11265 return SWIG_Python_InitShadowInstance(args);
11266 }
11267
11268 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11269 PyObject *resultobj = 0;
11270 wxString *arg1 = 0 ;
11271 wxImage *arg2 = 0 ;
11272 long arg3 ;
11273 bool temp1 = false ;
11274 void *argp2 = 0 ;
11275 int res2 = 0 ;
11276 long val3 ;
11277 int ecode3 = 0 ;
11278 PyObject * obj0 = 0 ;
11279 PyObject * obj1 = 0 ;
11280 PyObject * obj2 = 0 ;
11281 char * kwnames[] = {
11282 (char *) "filename",(char *) "image",(char *) "type", NULL
11283 };
11284
11285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11286 {
11287 arg1 = wxString_in_helper(obj0);
11288 if (arg1 == NULL) SWIG_fail;
11289 temp1 = true;
11290 }
11291 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11292 if (!SWIG_IsOK(res2)) {
11293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11294 }
11295 if (!argp2) {
11296 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11297 }
11298 arg2 = reinterpret_cast< wxImage * >(argp2);
11299 ecode3 = SWIG_AsVal_long(obj2, &val3);
11300 if (!SWIG_IsOK(ecode3)) {
11301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11302 }
11303 arg3 = static_cast< long >(val3);
11304 {
11305 PyThreadState* __tstate = wxPyBeginAllowThreads();
11306 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11307 wxPyEndAllowThreads(__tstate);
11308 if (PyErr_Occurred()) SWIG_fail;
11309 }
11310 resultobj = SWIG_Py_Void();
11311 {
11312 if (temp1)
11313 delete arg1;
11314 }
11315 return resultobj;
11316 fail:
11317 {
11318 if (temp1)
11319 delete arg1;
11320 }
11321 return NULL;
11322 }
11323
11324
11325 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11326 PyObject *resultobj = 0;
11327 wxString *arg1 = 0 ;
11328 wxBitmap *arg2 = 0 ;
11329 long arg3 ;
11330 bool temp1 = false ;
11331 void *argp2 = 0 ;
11332 int res2 = 0 ;
11333 long val3 ;
11334 int ecode3 = 0 ;
11335 PyObject * obj0 = 0 ;
11336 PyObject * obj1 = 0 ;
11337 PyObject * obj2 = 0 ;
11338 char * kwnames[] = {
11339 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11340 };
11341
11342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11343 {
11344 arg1 = wxString_in_helper(obj0);
11345 if (arg1 == NULL) SWIG_fail;
11346 temp1 = true;
11347 }
11348 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11349 if (!SWIG_IsOK(res2)) {
11350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11351 }
11352 if (!argp2) {
11353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11354 }
11355 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11356 ecode3 = SWIG_AsVal_long(obj2, &val3);
11357 if (!SWIG_IsOK(ecode3)) {
11358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11359 }
11360 arg3 = static_cast< long >(val3);
11361 {
11362 PyThreadState* __tstate = wxPyBeginAllowThreads();
11363 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11364 wxPyEndAllowThreads(__tstate);
11365 if (PyErr_Occurred()) SWIG_fail;
11366 }
11367 resultobj = SWIG_Py_Void();
11368 {
11369 if (temp1)
11370 delete arg1;
11371 }
11372 return resultobj;
11373 fail:
11374 {
11375 if (temp1)
11376 delete arg1;
11377 }
11378 return NULL;
11379 }
11380
11381
11382 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11383 PyObject *resultobj = 0;
11384 wxString *arg1 = 0 ;
11385 PyObject *arg2 = (PyObject *) 0 ;
11386 bool temp1 = false ;
11387 PyObject * obj0 = 0 ;
11388 PyObject * obj1 = 0 ;
11389 char * kwnames[] = {
11390 (char *) "filename",(char *) "data", NULL
11391 };
11392
11393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11394 {
11395 arg1 = wxString_in_helper(obj0);
11396 if (arg1 == NULL) SWIG_fail;
11397 temp1 = true;
11398 }
11399 arg2 = obj1;
11400 {
11401 PyThreadState* __tstate = wxPyBeginAllowThreads();
11402 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11403 wxPyEndAllowThreads(__tstate);
11404 if (PyErr_Occurred()) SWIG_fail;
11405 }
11406 resultobj = SWIG_Py_Void();
11407 {
11408 if (temp1)
11409 delete arg1;
11410 }
11411 return resultobj;
11412 fail:
11413 {
11414 if (temp1)
11415 delete arg1;
11416 }
11417 return NULL;
11418 }
11419
11420
11421 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11422 PyObject *resultobj = 0;
11423 wxMemoryFSHandler *result = 0 ;
11424
11425 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11426 {
11427 PyThreadState* __tstate = wxPyBeginAllowThreads();
11428 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11429 wxPyEndAllowThreads(__tstate);
11430 if (PyErr_Occurred()) SWIG_fail;
11431 }
11432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11433 return resultobj;
11434 fail:
11435 return NULL;
11436 }
11437
11438
11439 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11440 PyObject *resultobj = 0;
11441 wxString *arg1 = 0 ;
11442 bool temp1 = false ;
11443 PyObject * obj0 = 0 ;
11444 char * kwnames[] = {
11445 (char *) "filename", NULL
11446 };
11447
11448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11449 {
11450 arg1 = wxString_in_helper(obj0);
11451 if (arg1 == NULL) SWIG_fail;
11452 temp1 = true;
11453 }
11454 {
11455 PyThreadState* __tstate = wxPyBeginAllowThreads();
11456 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11457 wxPyEndAllowThreads(__tstate);
11458 if (PyErr_Occurred()) SWIG_fail;
11459 }
11460 resultobj = SWIG_Py_Void();
11461 {
11462 if (temp1)
11463 delete arg1;
11464 }
11465 return resultobj;
11466 fail:
11467 {
11468 if (temp1)
11469 delete arg1;
11470 }
11471 return NULL;
11472 }
11473
11474
11475 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11476 PyObject *resultobj = 0;
11477 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11478 wxString *arg2 = 0 ;
11479 bool result;
11480 void *argp1 = 0 ;
11481 int res1 = 0 ;
11482 bool temp2 = false ;
11483 PyObject * obj0 = 0 ;
11484 PyObject * obj1 = 0 ;
11485 char * kwnames[] = {
11486 (char *) "self",(char *) "location", NULL
11487 };
11488
11489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11491 if (!SWIG_IsOK(res1)) {
11492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11493 }
11494 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11495 {
11496 arg2 = wxString_in_helper(obj1);
11497 if (arg2 == NULL) SWIG_fail;
11498 temp2 = true;
11499 }
11500 {
11501 PyThreadState* __tstate = wxPyBeginAllowThreads();
11502 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11503 wxPyEndAllowThreads(__tstate);
11504 if (PyErr_Occurred()) SWIG_fail;
11505 }
11506 {
11507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11508 }
11509 {
11510 if (temp2)
11511 delete arg2;
11512 }
11513 return resultobj;
11514 fail:
11515 {
11516 if (temp2)
11517 delete arg2;
11518 }
11519 return NULL;
11520 }
11521
11522
11523 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11524 PyObject *resultobj = 0;
11525 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11526 wxFileSystem *arg2 = 0 ;
11527 wxString *arg3 = 0 ;
11528 wxFSFile *result = 0 ;
11529 void *argp1 = 0 ;
11530 int res1 = 0 ;
11531 void *argp2 = 0 ;
11532 int res2 = 0 ;
11533 bool temp3 = false ;
11534 PyObject * obj0 = 0 ;
11535 PyObject * obj1 = 0 ;
11536 PyObject * obj2 = 0 ;
11537 char * kwnames[] = {
11538 (char *) "self",(char *) "fs",(char *) "location", NULL
11539 };
11540
11541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11543 if (!SWIG_IsOK(res1)) {
11544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11545 }
11546 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11547 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11548 if (!SWIG_IsOK(res2)) {
11549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11550 }
11551 if (!argp2) {
11552 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11553 }
11554 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11555 {
11556 arg3 = wxString_in_helper(obj2);
11557 if (arg3 == NULL) SWIG_fail;
11558 temp3 = true;
11559 }
11560 {
11561 PyThreadState* __tstate = wxPyBeginAllowThreads();
11562 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11563 wxPyEndAllowThreads(__tstate);
11564 if (PyErr_Occurred()) SWIG_fail;
11565 }
11566 {
11567 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11568 }
11569 {
11570 if (temp3)
11571 delete arg3;
11572 }
11573 return resultobj;
11574 fail:
11575 {
11576 if (temp3)
11577 delete arg3;
11578 }
11579 return NULL;
11580 }
11581
11582
11583 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11584 PyObject *resultobj = 0;
11585 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11586 wxString *arg2 = 0 ;
11587 int arg3 = (int) 0 ;
11588 wxString result;
11589 void *argp1 = 0 ;
11590 int res1 = 0 ;
11591 bool temp2 = false ;
11592 int val3 ;
11593 int ecode3 = 0 ;
11594 PyObject * obj0 = 0 ;
11595 PyObject * obj1 = 0 ;
11596 PyObject * obj2 = 0 ;
11597 char * kwnames[] = {
11598 (char *) "self",(char *) "spec",(char *) "flags", NULL
11599 };
11600
11601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11603 if (!SWIG_IsOK(res1)) {
11604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11605 }
11606 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11607 {
11608 arg2 = wxString_in_helper(obj1);
11609 if (arg2 == NULL) SWIG_fail;
11610 temp2 = true;
11611 }
11612 if (obj2) {
11613 ecode3 = SWIG_AsVal_int(obj2, &val3);
11614 if (!SWIG_IsOK(ecode3)) {
11615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11616 }
11617 arg3 = static_cast< int >(val3);
11618 }
11619 {
11620 PyThreadState* __tstate = wxPyBeginAllowThreads();
11621 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11622 wxPyEndAllowThreads(__tstate);
11623 if (PyErr_Occurred()) SWIG_fail;
11624 }
11625 {
11626 #if wxUSE_UNICODE
11627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11628 #else
11629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11630 #endif
11631 }
11632 {
11633 if (temp2)
11634 delete arg2;
11635 }
11636 return resultobj;
11637 fail:
11638 {
11639 if (temp2)
11640 delete arg2;
11641 }
11642 return NULL;
11643 }
11644
11645
11646 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11647 PyObject *resultobj = 0;
11648 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11649 wxString result;
11650 void *argp1 = 0 ;
11651 int res1 = 0 ;
11652 PyObject *swig_obj[1] ;
11653
11654 if (!args) SWIG_fail;
11655 swig_obj[0] = args;
11656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11657 if (!SWIG_IsOK(res1)) {
11658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11659 }
11660 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11661 {
11662 PyThreadState* __tstate = wxPyBeginAllowThreads();
11663 result = (arg1)->FindNext();
11664 wxPyEndAllowThreads(__tstate);
11665 if (PyErr_Occurred()) SWIG_fail;
11666 }
11667 {
11668 #if wxUSE_UNICODE
11669 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11670 #else
11671 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11672 #endif
11673 }
11674 return resultobj;
11675 fail:
11676 return NULL;
11677 }
11678
11679
11680 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11681 PyObject *obj;
11682 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11683 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11684 return SWIG_Py_Void();
11685 }
11686
11687 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11688 return SWIG_Python_InitShadowInstance(args);
11689 }
11690
11691 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11692 PyObject *resultobj = 0;
11693 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11694 wxString result;
11695 void *argp1 = 0 ;
11696 int res1 = 0 ;
11697 PyObject *swig_obj[1] ;
11698
11699 if (!args) SWIG_fail;
11700 swig_obj[0] = args;
11701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11702 if (!SWIG_IsOK(res1)) {
11703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11704 }
11705 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11706 {
11707 PyThreadState* __tstate = wxPyBeginAllowThreads();
11708 result = (arg1)->GetName();
11709 wxPyEndAllowThreads(__tstate);
11710 if (PyErr_Occurred()) SWIG_fail;
11711 }
11712 {
11713 #if wxUSE_UNICODE
11714 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11715 #else
11716 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11717 #endif
11718 }
11719 return resultobj;
11720 fail:
11721 return NULL;
11722 }
11723
11724
11725 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11726 PyObject *resultobj = 0;
11727 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11728 wxString result;
11729 void *argp1 = 0 ;
11730 int res1 = 0 ;
11731 PyObject *swig_obj[1] ;
11732
11733 if (!args) SWIG_fail;
11734 swig_obj[0] = args;
11735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11736 if (!SWIG_IsOK(res1)) {
11737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11738 }
11739 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11740 {
11741 PyThreadState* __tstate = wxPyBeginAllowThreads();
11742 result = (arg1)->GetExtension();
11743 wxPyEndAllowThreads(__tstate);
11744 if (PyErr_Occurred()) SWIG_fail;
11745 }
11746 {
11747 #if wxUSE_UNICODE
11748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11749 #else
11750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11751 #endif
11752 }
11753 return resultobj;
11754 fail:
11755 return NULL;
11756 }
11757
11758
11759 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11760 PyObject *resultobj = 0;
11761 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11762 long result;
11763 void *argp1 = 0 ;
11764 int res1 = 0 ;
11765 PyObject *swig_obj[1] ;
11766
11767 if (!args) SWIG_fail;
11768 swig_obj[0] = args;
11769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11770 if (!SWIG_IsOK(res1)) {
11771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11772 }
11773 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11774 {
11775 PyThreadState* __tstate = wxPyBeginAllowThreads();
11776 result = (long)(arg1)->GetType();
11777 wxPyEndAllowThreads(__tstate);
11778 if (PyErr_Occurred()) SWIG_fail;
11779 }
11780 resultobj = SWIG_From_long(static_cast< long >(result));
11781 return resultobj;
11782 fail:
11783 return NULL;
11784 }
11785
11786
11787 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11788 PyObject *resultobj = 0;
11789 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11790 wxString result;
11791 void *argp1 = 0 ;
11792 int res1 = 0 ;
11793 PyObject *swig_obj[1] ;
11794
11795 if (!args) SWIG_fail;
11796 swig_obj[0] = args;
11797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11798 if (!SWIG_IsOK(res1)) {
11799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11800 }
11801 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11802 {
11803 PyThreadState* __tstate = wxPyBeginAllowThreads();
11804 result = (arg1)->GetMimeType();
11805 wxPyEndAllowThreads(__tstate);
11806 if (PyErr_Occurred()) SWIG_fail;
11807 }
11808 {
11809 #if wxUSE_UNICODE
11810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11811 #else
11812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11813 #endif
11814 }
11815 return resultobj;
11816 fail:
11817 return NULL;
11818 }
11819
11820
11821 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11822 PyObject *resultobj = 0;
11823 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11824 wxString *arg2 = 0 ;
11825 bool result;
11826 void *argp1 = 0 ;
11827 int res1 = 0 ;
11828 bool temp2 = false ;
11829 PyObject * obj0 = 0 ;
11830 PyObject * obj1 = 0 ;
11831 char * kwnames[] = {
11832 (char *) "self",(char *) "name", NULL
11833 };
11834
11835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11837 if (!SWIG_IsOK(res1)) {
11838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11839 }
11840 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11841 {
11842 arg2 = wxString_in_helper(obj1);
11843 if (arg2 == NULL) SWIG_fail;
11844 temp2 = true;
11845 }
11846 {
11847 PyThreadState* __tstate = wxPyBeginAllowThreads();
11848 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11849 wxPyEndAllowThreads(__tstate);
11850 if (PyErr_Occurred()) SWIG_fail;
11851 }
11852 {
11853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11854 }
11855 {
11856 if (temp2)
11857 delete arg2;
11858 }
11859 return resultobj;
11860 fail:
11861 {
11862 if (temp2)
11863 delete arg2;
11864 }
11865 return NULL;
11866 }
11867
11868
11869 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11870 PyObject *resultobj = 0;
11871 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11872 wxInputStream *arg2 = 0 ;
11873 bool result;
11874 void *argp1 = 0 ;
11875 int res1 = 0 ;
11876 wxPyInputStream *temp2 ;
11877 bool created2 ;
11878 PyObject * obj0 = 0 ;
11879 PyObject * obj1 = 0 ;
11880 char * kwnames[] = {
11881 (char *) "self",(char *) "stream", NULL
11882 };
11883
11884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11886 if (!SWIG_IsOK(res1)) {
11887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11888 }
11889 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11890 {
11891 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11892 arg2 = temp2->m_wxis;
11893 created2 = false;
11894 } else {
11895 PyErr_Clear(); // clear the failure of the wxPyConvert above
11896 arg2 = wxPyCBInputStream_create(obj1, false);
11897 if (arg2 == NULL) {
11898 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11899 SWIG_fail;
11900 }
11901 created2 = true;
11902 }
11903 }
11904 {
11905 PyThreadState* __tstate = wxPyBeginAllowThreads();
11906 result = (bool)(arg1)->CanRead(*arg2);
11907 wxPyEndAllowThreads(__tstate);
11908 if (PyErr_Occurred()) SWIG_fail;
11909 }
11910 {
11911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11912 }
11913 {
11914 if (created2) delete arg2;
11915 }
11916 return resultobj;
11917 fail:
11918 {
11919 if (created2) delete arg2;
11920 }
11921 return NULL;
11922 }
11923
11924
11925 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11926 PyObject *resultobj = 0;
11927 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11928 wxString *arg2 = 0 ;
11929 void *argp1 = 0 ;
11930 int res1 = 0 ;
11931 bool temp2 = false ;
11932 PyObject * obj0 = 0 ;
11933 PyObject * obj1 = 0 ;
11934 char * kwnames[] = {
11935 (char *) "self",(char *) "name", NULL
11936 };
11937
11938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11940 if (!SWIG_IsOK(res1)) {
11941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11942 }
11943 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11944 {
11945 arg2 = wxString_in_helper(obj1);
11946 if (arg2 == NULL) SWIG_fail;
11947 temp2 = true;
11948 }
11949 {
11950 PyThreadState* __tstate = wxPyBeginAllowThreads();
11951 (arg1)->SetName((wxString const &)*arg2);
11952 wxPyEndAllowThreads(__tstate);
11953 if (PyErr_Occurred()) SWIG_fail;
11954 }
11955 resultobj = SWIG_Py_Void();
11956 {
11957 if (temp2)
11958 delete arg2;
11959 }
11960 return resultobj;
11961 fail:
11962 {
11963 if (temp2)
11964 delete arg2;
11965 }
11966 return NULL;
11967 }
11968
11969
11970 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11971 PyObject *resultobj = 0;
11972 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11973 wxString *arg2 = 0 ;
11974 void *argp1 = 0 ;
11975 int res1 = 0 ;
11976 bool temp2 = false ;
11977 PyObject * obj0 = 0 ;
11978 PyObject * obj1 = 0 ;
11979 char * kwnames[] = {
11980 (char *) "self",(char *) "extension", NULL
11981 };
11982
11983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11985 if (!SWIG_IsOK(res1)) {
11986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11987 }
11988 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11989 {
11990 arg2 = wxString_in_helper(obj1);
11991 if (arg2 == NULL) SWIG_fail;
11992 temp2 = true;
11993 }
11994 {
11995 PyThreadState* __tstate = wxPyBeginAllowThreads();
11996 (arg1)->SetExtension((wxString const &)*arg2);
11997 wxPyEndAllowThreads(__tstate);
11998 if (PyErr_Occurred()) SWIG_fail;
11999 }
12000 resultobj = SWIG_Py_Void();
12001 {
12002 if (temp2)
12003 delete arg2;
12004 }
12005 return resultobj;
12006 fail:
12007 {
12008 if (temp2)
12009 delete arg2;
12010 }
12011 return NULL;
12012 }
12013
12014
12015 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12016 PyObject *resultobj = 0;
12017 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12018 long arg2 ;
12019 void *argp1 = 0 ;
12020 int res1 = 0 ;
12021 long val2 ;
12022 int ecode2 = 0 ;
12023 PyObject * obj0 = 0 ;
12024 PyObject * obj1 = 0 ;
12025 char * kwnames[] = {
12026 (char *) "self",(char *) "type", NULL
12027 };
12028
12029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12031 if (!SWIG_IsOK(res1)) {
12032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12033 }
12034 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12035 ecode2 = SWIG_AsVal_long(obj1, &val2);
12036 if (!SWIG_IsOK(ecode2)) {
12037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12038 }
12039 arg2 = static_cast< long >(val2);
12040 {
12041 PyThreadState* __tstate = wxPyBeginAllowThreads();
12042 (arg1)->SetType(arg2);
12043 wxPyEndAllowThreads(__tstate);
12044 if (PyErr_Occurred()) SWIG_fail;
12045 }
12046 resultobj = SWIG_Py_Void();
12047 return resultobj;
12048 fail:
12049 return NULL;
12050 }
12051
12052
12053 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12054 PyObject *resultobj = 0;
12055 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12056 wxString *arg2 = 0 ;
12057 void *argp1 = 0 ;
12058 int res1 = 0 ;
12059 bool temp2 = false ;
12060 PyObject * obj0 = 0 ;
12061 PyObject * obj1 = 0 ;
12062 char * kwnames[] = {
12063 (char *) "self",(char *) "mimetype", NULL
12064 };
12065
12066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12068 if (!SWIG_IsOK(res1)) {
12069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12070 }
12071 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12072 {
12073 arg2 = wxString_in_helper(obj1);
12074 if (arg2 == NULL) SWIG_fail;
12075 temp2 = true;
12076 }
12077 {
12078 PyThreadState* __tstate = wxPyBeginAllowThreads();
12079 (arg1)->SetMimeType((wxString const &)*arg2);
12080 wxPyEndAllowThreads(__tstate);
12081 if (PyErr_Occurred()) SWIG_fail;
12082 }
12083 resultobj = SWIG_Py_Void();
12084 {
12085 if (temp2)
12086 delete arg2;
12087 }
12088 return resultobj;
12089 fail:
12090 {
12091 if (temp2)
12092 delete arg2;
12093 }
12094 return NULL;
12095 }
12096
12097
12098 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12099 PyObject *obj;
12100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12101 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12102 return SWIG_Py_Void();
12103 }
12104
12105 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12106 PyObject *resultobj = 0;
12107 wxPyImageHandler *result = 0 ;
12108
12109 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12110 {
12111 PyThreadState* __tstate = wxPyBeginAllowThreads();
12112 result = (wxPyImageHandler *)new wxPyImageHandler();
12113 wxPyEndAllowThreads(__tstate);
12114 if (PyErr_Occurred()) SWIG_fail;
12115 }
12116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12117 return resultobj;
12118 fail:
12119 return NULL;
12120 }
12121
12122
12123 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12124 PyObject *resultobj = 0;
12125 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12126 PyObject *arg2 = (PyObject *) 0 ;
12127 void *argp1 = 0 ;
12128 int res1 = 0 ;
12129 PyObject * obj0 = 0 ;
12130 PyObject * obj1 = 0 ;
12131 char * kwnames[] = {
12132 (char *) "self",(char *) "self", NULL
12133 };
12134
12135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12137 if (!SWIG_IsOK(res1)) {
12138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12139 }
12140 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12141 arg2 = obj1;
12142 {
12143 PyThreadState* __tstate = wxPyBeginAllowThreads();
12144 (arg1)->_SetSelf(arg2);
12145 wxPyEndAllowThreads(__tstate);
12146 if (PyErr_Occurred()) SWIG_fail;
12147 }
12148 resultobj = SWIG_Py_Void();
12149 return resultobj;
12150 fail:
12151 return NULL;
12152 }
12153
12154
12155 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12156 PyObject *obj;
12157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12158 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12159 return SWIG_Py_Void();
12160 }
12161
12162 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12163 return SWIG_Python_InitShadowInstance(args);
12164 }
12165
12166 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12167 PyObject *resultobj = 0;
12168 wxImageHistogram *result = 0 ;
12169
12170 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12171 {
12172 PyThreadState* __tstate = wxPyBeginAllowThreads();
12173 result = (wxImageHistogram *)new wxImageHistogram();
12174 wxPyEndAllowThreads(__tstate);
12175 if (PyErr_Occurred()) SWIG_fail;
12176 }
12177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12178 return resultobj;
12179 fail:
12180 return NULL;
12181 }
12182
12183
12184 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12185 PyObject *resultobj = 0;
12186 byte arg1 ;
12187 byte arg2 ;
12188 byte arg3 ;
12189 unsigned long result;
12190 unsigned char val1 ;
12191 int ecode1 = 0 ;
12192 unsigned char val2 ;
12193 int ecode2 = 0 ;
12194 unsigned char val3 ;
12195 int ecode3 = 0 ;
12196 PyObject * obj0 = 0 ;
12197 PyObject * obj1 = 0 ;
12198 PyObject * obj2 = 0 ;
12199 char * kwnames[] = {
12200 (char *) "r",(char *) "g",(char *) "b", NULL
12201 };
12202
12203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12204 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12205 if (!SWIG_IsOK(ecode1)) {
12206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12207 }
12208 arg1 = static_cast< byte >(val1);
12209 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12210 if (!SWIG_IsOK(ecode2)) {
12211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12212 }
12213 arg2 = static_cast< byte >(val2);
12214 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12215 if (!SWIG_IsOK(ecode3)) {
12216 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12217 }
12218 arg3 = static_cast< byte >(val3);
12219 {
12220 PyThreadState* __tstate = wxPyBeginAllowThreads();
12221 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12222 wxPyEndAllowThreads(__tstate);
12223 if (PyErr_Occurred()) SWIG_fail;
12224 }
12225 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12226 return resultobj;
12227 fail:
12228 return NULL;
12229 }
12230
12231
12232 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12233 PyObject *resultobj = 0;
12234 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12235 byte *arg2 = (byte *) 0 ;
12236 byte *arg3 = (byte *) 0 ;
12237 byte *arg4 = (byte *) 0 ;
12238 byte arg5 = (byte) 1 ;
12239 byte arg6 = (byte) 0 ;
12240 byte arg7 = (byte) 0 ;
12241 bool result;
12242 void *argp1 = 0 ;
12243 int res1 = 0 ;
12244 byte temp2 ;
12245 int res2 = SWIG_TMPOBJ ;
12246 byte temp3 ;
12247 int res3 = SWIG_TMPOBJ ;
12248 byte temp4 ;
12249 int res4 = SWIG_TMPOBJ ;
12250 unsigned char val5 ;
12251 int ecode5 = 0 ;
12252 unsigned char val6 ;
12253 int ecode6 = 0 ;
12254 unsigned char val7 ;
12255 int ecode7 = 0 ;
12256 PyObject * obj0 = 0 ;
12257 PyObject * obj1 = 0 ;
12258 PyObject * obj2 = 0 ;
12259 PyObject * obj3 = 0 ;
12260 char * kwnames[] = {
12261 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12262 };
12263
12264 arg2 = &temp2;
12265 arg3 = &temp3;
12266 arg4 = &temp4;
12267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12269 if (!SWIG_IsOK(res1)) {
12270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12271 }
12272 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12273 if (obj1) {
12274 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12275 if (!SWIG_IsOK(ecode5)) {
12276 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12277 }
12278 arg5 = static_cast< byte >(val5);
12279 }
12280 if (obj2) {
12281 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12282 if (!SWIG_IsOK(ecode6)) {
12283 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12284 }
12285 arg6 = static_cast< byte >(val6);
12286 }
12287 if (obj3) {
12288 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12289 if (!SWIG_IsOK(ecode7)) {
12290 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12291 }
12292 arg7 = static_cast< byte >(val7);
12293 }
12294 {
12295 PyThreadState* __tstate = wxPyBeginAllowThreads();
12296 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12297 wxPyEndAllowThreads(__tstate);
12298 if (PyErr_Occurred()) SWIG_fail;
12299 }
12300 {
12301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12302 }
12303 if (SWIG_IsTmpObj(res2)) {
12304 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12305 } else {
12306 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12307 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12308 }
12309 if (SWIG_IsTmpObj(res3)) {
12310 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12311 } else {
12312 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12313 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12314 }
12315 if (SWIG_IsTmpObj(res4)) {
12316 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12317 } else {
12318 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12319 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12320 }
12321 return resultobj;
12322 fail:
12323 return NULL;
12324 }
12325
12326
12327 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12328 PyObject *resultobj = 0;
12329 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12330 unsigned long arg2 ;
12331 unsigned long result;
12332 void *argp1 = 0 ;
12333 int res1 = 0 ;
12334 unsigned long val2 ;
12335 int ecode2 = 0 ;
12336 PyObject * obj0 = 0 ;
12337 PyObject * obj1 = 0 ;
12338 char * kwnames[] = {
12339 (char *) "self",(char *) "key", NULL
12340 };
12341
12342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12344 if (!SWIG_IsOK(res1)) {
12345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12346 }
12347 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12348 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12349 if (!SWIG_IsOK(ecode2)) {
12350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12351 }
12352 arg2 = static_cast< unsigned long >(val2);
12353 {
12354 PyThreadState* __tstate = wxPyBeginAllowThreads();
12355 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12356 wxPyEndAllowThreads(__tstate);
12357 if (PyErr_Occurred()) SWIG_fail;
12358 }
12359 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12360 return resultobj;
12361 fail:
12362 return NULL;
12363 }
12364
12365
12366 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12367 PyObject *resultobj = 0;
12368 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12369 byte arg2 ;
12370 byte arg3 ;
12371 byte arg4 ;
12372 unsigned long result;
12373 void *argp1 = 0 ;
12374 int res1 = 0 ;
12375 unsigned char val2 ;
12376 int ecode2 = 0 ;
12377 unsigned char val3 ;
12378 int ecode3 = 0 ;
12379 unsigned char val4 ;
12380 int ecode4 = 0 ;
12381 PyObject * obj0 = 0 ;
12382 PyObject * obj1 = 0 ;
12383 PyObject * obj2 = 0 ;
12384 PyObject * obj3 = 0 ;
12385 char * kwnames[] = {
12386 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12387 };
12388
12389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12391 if (!SWIG_IsOK(res1)) {
12392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12393 }
12394 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12395 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12396 if (!SWIG_IsOK(ecode2)) {
12397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12398 }
12399 arg2 = static_cast< byte >(val2);
12400 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12401 if (!SWIG_IsOK(ecode3)) {
12402 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12403 }
12404 arg3 = static_cast< byte >(val3);
12405 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12406 if (!SWIG_IsOK(ecode4)) {
12407 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12408 }
12409 arg4 = static_cast< byte >(val4);
12410 {
12411 PyThreadState* __tstate = wxPyBeginAllowThreads();
12412 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12413 wxPyEndAllowThreads(__tstate);
12414 if (PyErr_Occurred()) SWIG_fail;
12415 }
12416 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12417 return resultobj;
12418 fail:
12419 return NULL;
12420 }
12421
12422
12423 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12424 PyObject *resultobj = 0;
12425 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12426 wxColour *arg2 = 0 ;
12427 unsigned long result;
12428 void *argp1 = 0 ;
12429 int res1 = 0 ;
12430 wxColour temp2 ;
12431 PyObject * obj0 = 0 ;
12432 PyObject * obj1 = 0 ;
12433 char * kwnames[] = {
12434 (char *) "self",(char *) "colour", NULL
12435 };
12436
12437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12439 if (!SWIG_IsOK(res1)) {
12440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12441 }
12442 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12443 {
12444 arg2 = &temp2;
12445 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12446 }
12447 {
12448 PyThreadState* __tstate = wxPyBeginAllowThreads();
12449 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12450 wxPyEndAllowThreads(__tstate);
12451 if (PyErr_Occurred()) SWIG_fail;
12452 }
12453 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12454 return resultobj;
12455 fail:
12456 return NULL;
12457 }
12458
12459
12460 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12461 PyObject *obj;
12462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12463 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12464 return SWIG_Py_Void();
12465 }
12466
12467 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12468 return SWIG_Python_InitShadowInstance(args);
12469 }
12470
12471 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12472 PyObject *resultobj = 0;
12473 byte arg1 = (byte) 0 ;
12474 byte arg2 = (byte) 0 ;
12475 byte arg3 = (byte) 0 ;
12476 wxImage_RGBValue *result = 0 ;
12477 unsigned char val1 ;
12478 int ecode1 = 0 ;
12479 unsigned char val2 ;
12480 int ecode2 = 0 ;
12481 unsigned char val3 ;
12482 int ecode3 = 0 ;
12483 PyObject * obj0 = 0 ;
12484 PyObject * obj1 = 0 ;
12485 PyObject * obj2 = 0 ;
12486 char * kwnames[] = {
12487 (char *) "r",(char *) "g",(char *) "b", NULL
12488 };
12489
12490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12491 if (obj0) {
12492 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12493 if (!SWIG_IsOK(ecode1)) {
12494 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12495 }
12496 arg1 = static_cast< byte >(val1);
12497 }
12498 if (obj1) {
12499 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12500 if (!SWIG_IsOK(ecode2)) {
12501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12502 }
12503 arg2 = static_cast< byte >(val2);
12504 }
12505 if (obj2) {
12506 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12507 if (!SWIG_IsOK(ecode3)) {
12508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12509 }
12510 arg3 = static_cast< byte >(val3);
12511 }
12512 {
12513 PyThreadState* __tstate = wxPyBeginAllowThreads();
12514 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12515 wxPyEndAllowThreads(__tstate);
12516 if (PyErr_Occurred()) SWIG_fail;
12517 }
12518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12519 return resultobj;
12520 fail:
12521 return NULL;
12522 }
12523
12524
12525 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12526 PyObject *resultobj = 0;
12527 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12528 byte arg2 ;
12529 void *argp1 = 0 ;
12530 int res1 = 0 ;
12531 unsigned char val2 ;
12532 int ecode2 = 0 ;
12533 PyObject *swig_obj[2] ;
12534
12535 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12537 if (!SWIG_IsOK(res1)) {
12538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12539 }
12540 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12541 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12542 if (!SWIG_IsOK(ecode2)) {
12543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12544 }
12545 arg2 = static_cast< byte >(val2);
12546 if (arg1) (arg1)->red = arg2;
12547
12548 resultobj = SWIG_Py_Void();
12549 return resultobj;
12550 fail:
12551 return NULL;
12552 }
12553
12554
12555 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12556 PyObject *resultobj = 0;
12557 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12558 byte result;
12559 void *argp1 = 0 ;
12560 int res1 = 0 ;
12561 PyObject *swig_obj[1] ;
12562
12563 if (!args) SWIG_fail;
12564 swig_obj[0] = args;
12565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12566 if (!SWIG_IsOK(res1)) {
12567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12568 }
12569 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12570 result = (byte) ((arg1)->red);
12571 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12572 return resultobj;
12573 fail:
12574 return NULL;
12575 }
12576
12577
12578 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12579 PyObject *resultobj = 0;
12580 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12581 byte arg2 ;
12582 void *argp1 = 0 ;
12583 int res1 = 0 ;
12584 unsigned char val2 ;
12585 int ecode2 = 0 ;
12586 PyObject *swig_obj[2] ;
12587
12588 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12590 if (!SWIG_IsOK(res1)) {
12591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12592 }
12593 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12594 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12595 if (!SWIG_IsOK(ecode2)) {
12596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12597 }
12598 arg2 = static_cast< byte >(val2);
12599 if (arg1) (arg1)->green = arg2;
12600
12601 resultobj = SWIG_Py_Void();
12602 return resultobj;
12603 fail:
12604 return NULL;
12605 }
12606
12607
12608 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12609 PyObject *resultobj = 0;
12610 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12611 byte result;
12612 void *argp1 = 0 ;
12613 int res1 = 0 ;
12614 PyObject *swig_obj[1] ;
12615
12616 if (!args) SWIG_fail;
12617 swig_obj[0] = args;
12618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12619 if (!SWIG_IsOK(res1)) {
12620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12621 }
12622 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12623 result = (byte) ((arg1)->green);
12624 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12625 return resultobj;
12626 fail:
12627 return NULL;
12628 }
12629
12630
12631 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12632 PyObject *resultobj = 0;
12633 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12634 byte arg2 ;
12635 void *argp1 = 0 ;
12636 int res1 = 0 ;
12637 unsigned char val2 ;
12638 int ecode2 = 0 ;
12639 PyObject *swig_obj[2] ;
12640
12641 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12643 if (!SWIG_IsOK(res1)) {
12644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12645 }
12646 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12647 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12648 if (!SWIG_IsOK(ecode2)) {
12649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12650 }
12651 arg2 = static_cast< byte >(val2);
12652 if (arg1) (arg1)->blue = arg2;
12653
12654 resultobj = SWIG_Py_Void();
12655 return resultobj;
12656 fail:
12657 return NULL;
12658 }
12659
12660
12661 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12662 PyObject *resultobj = 0;
12663 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12664 byte result;
12665 void *argp1 = 0 ;
12666 int res1 = 0 ;
12667 PyObject *swig_obj[1] ;
12668
12669 if (!args) SWIG_fail;
12670 swig_obj[0] = args;
12671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12672 if (!SWIG_IsOK(res1)) {
12673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12674 }
12675 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12676 result = (byte) ((arg1)->blue);
12677 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12678 return resultobj;
12679 fail:
12680 return NULL;
12681 }
12682
12683
12684 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12685 PyObject *obj;
12686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12687 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12688 return SWIG_Py_Void();
12689 }
12690
12691 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12692 return SWIG_Python_InitShadowInstance(args);
12693 }
12694
12695 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12696 PyObject *resultobj = 0;
12697 double arg1 = (double) 0.0 ;
12698 double arg2 = (double) 0.0 ;
12699 double arg3 = (double) 0.0 ;
12700 wxImage_HSVValue *result = 0 ;
12701 double val1 ;
12702 int ecode1 = 0 ;
12703 double val2 ;
12704 int ecode2 = 0 ;
12705 double val3 ;
12706 int ecode3 = 0 ;
12707 PyObject * obj0 = 0 ;
12708 PyObject * obj1 = 0 ;
12709 PyObject * obj2 = 0 ;
12710 char * kwnames[] = {
12711 (char *) "h",(char *) "s",(char *) "v", NULL
12712 };
12713
12714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12715 if (obj0) {
12716 ecode1 = SWIG_AsVal_double(obj0, &val1);
12717 if (!SWIG_IsOK(ecode1)) {
12718 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12719 }
12720 arg1 = static_cast< double >(val1);
12721 }
12722 if (obj1) {
12723 ecode2 = SWIG_AsVal_double(obj1, &val2);
12724 if (!SWIG_IsOK(ecode2)) {
12725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12726 }
12727 arg2 = static_cast< double >(val2);
12728 }
12729 if (obj2) {
12730 ecode3 = SWIG_AsVal_double(obj2, &val3);
12731 if (!SWIG_IsOK(ecode3)) {
12732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12733 }
12734 arg3 = static_cast< double >(val3);
12735 }
12736 {
12737 PyThreadState* __tstate = wxPyBeginAllowThreads();
12738 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12739 wxPyEndAllowThreads(__tstate);
12740 if (PyErr_Occurred()) SWIG_fail;
12741 }
12742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12743 return resultobj;
12744 fail:
12745 return NULL;
12746 }
12747
12748
12749 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12750 PyObject *resultobj = 0;
12751 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12752 double arg2 ;
12753 void *argp1 = 0 ;
12754 int res1 = 0 ;
12755 double val2 ;
12756 int ecode2 = 0 ;
12757 PyObject *swig_obj[2] ;
12758
12759 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12761 if (!SWIG_IsOK(res1)) {
12762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12763 }
12764 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12765 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12766 if (!SWIG_IsOK(ecode2)) {
12767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12768 }
12769 arg2 = static_cast< double >(val2);
12770 if (arg1) (arg1)->hue = arg2;
12771
12772 resultobj = SWIG_Py_Void();
12773 return resultobj;
12774 fail:
12775 return NULL;
12776 }
12777
12778
12779 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12780 PyObject *resultobj = 0;
12781 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12782 double result;
12783 void *argp1 = 0 ;
12784 int res1 = 0 ;
12785 PyObject *swig_obj[1] ;
12786
12787 if (!args) SWIG_fail;
12788 swig_obj[0] = args;
12789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12790 if (!SWIG_IsOK(res1)) {
12791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12792 }
12793 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12794 result = (double) ((arg1)->hue);
12795 resultobj = SWIG_From_double(static_cast< double >(result));
12796 return resultobj;
12797 fail:
12798 return NULL;
12799 }
12800
12801
12802 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12803 PyObject *resultobj = 0;
12804 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12805 double arg2 ;
12806 void *argp1 = 0 ;
12807 int res1 = 0 ;
12808 double val2 ;
12809 int ecode2 = 0 ;
12810 PyObject *swig_obj[2] ;
12811
12812 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12814 if (!SWIG_IsOK(res1)) {
12815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12816 }
12817 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12818 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12819 if (!SWIG_IsOK(ecode2)) {
12820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12821 }
12822 arg2 = static_cast< double >(val2);
12823 if (arg1) (arg1)->saturation = arg2;
12824
12825 resultobj = SWIG_Py_Void();
12826 return resultobj;
12827 fail:
12828 return NULL;
12829 }
12830
12831
12832 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12833 PyObject *resultobj = 0;
12834 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12835 double result;
12836 void *argp1 = 0 ;
12837 int res1 = 0 ;
12838 PyObject *swig_obj[1] ;
12839
12840 if (!args) SWIG_fail;
12841 swig_obj[0] = args;
12842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12843 if (!SWIG_IsOK(res1)) {
12844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12845 }
12846 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12847 result = (double) ((arg1)->saturation);
12848 resultobj = SWIG_From_double(static_cast< double >(result));
12849 return resultobj;
12850 fail:
12851 return NULL;
12852 }
12853
12854
12855 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12856 PyObject *resultobj = 0;
12857 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12858 double arg2 ;
12859 void *argp1 = 0 ;
12860 int res1 = 0 ;
12861 double val2 ;
12862 int ecode2 = 0 ;
12863 PyObject *swig_obj[2] ;
12864
12865 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12867 if (!SWIG_IsOK(res1)) {
12868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12869 }
12870 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12871 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12872 if (!SWIG_IsOK(ecode2)) {
12873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12874 }
12875 arg2 = static_cast< double >(val2);
12876 if (arg1) (arg1)->value = arg2;
12877
12878 resultobj = SWIG_Py_Void();
12879 return resultobj;
12880 fail:
12881 return NULL;
12882 }
12883
12884
12885 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12886 PyObject *resultobj = 0;
12887 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12888 double result;
12889 void *argp1 = 0 ;
12890 int res1 = 0 ;
12891 PyObject *swig_obj[1] ;
12892
12893 if (!args) SWIG_fail;
12894 swig_obj[0] = args;
12895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12896 if (!SWIG_IsOK(res1)) {
12897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12898 }
12899 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12900 result = (double) ((arg1)->value);
12901 resultobj = SWIG_From_double(static_cast< double >(result));
12902 return resultobj;
12903 fail:
12904 return NULL;
12905 }
12906
12907
12908 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12909 PyObject *obj;
12910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12911 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12912 return SWIG_Py_Void();
12913 }
12914
12915 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12916 return SWIG_Python_InitShadowInstance(args);
12917 }
12918
12919 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12920 PyObject *resultobj = 0;
12921 wxString *arg1 = 0 ;
12922 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12923 int arg3 = (int) -1 ;
12924 wxImage *result = 0 ;
12925 bool temp1 = false ;
12926 long val2 ;
12927 int ecode2 = 0 ;
12928 int val3 ;
12929 int ecode3 = 0 ;
12930 PyObject * obj0 = 0 ;
12931 PyObject * obj1 = 0 ;
12932 PyObject * obj2 = 0 ;
12933 char * kwnames[] = {
12934 (char *) "name",(char *) "type",(char *) "index", NULL
12935 };
12936
12937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12938 {
12939 arg1 = wxString_in_helper(obj0);
12940 if (arg1 == NULL) SWIG_fail;
12941 temp1 = true;
12942 }
12943 if (obj1) {
12944 ecode2 = SWIG_AsVal_long(obj1, &val2);
12945 if (!SWIG_IsOK(ecode2)) {
12946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12947 }
12948 arg2 = static_cast< long >(val2);
12949 }
12950 if (obj2) {
12951 ecode3 = SWIG_AsVal_int(obj2, &val3);
12952 if (!SWIG_IsOK(ecode3)) {
12953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12954 }
12955 arg3 = static_cast< int >(val3);
12956 }
12957 {
12958 PyThreadState* __tstate = wxPyBeginAllowThreads();
12959 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12960 wxPyEndAllowThreads(__tstate);
12961 if (PyErr_Occurred()) SWIG_fail;
12962 }
12963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12964 {
12965 if (temp1)
12966 delete arg1;
12967 }
12968 return resultobj;
12969 fail:
12970 {
12971 if (temp1)
12972 delete arg1;
12973 }
12974 return NULL;
12975 }
12976
12977
12978 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12979 PyObject *resultobj = 0;
12980 wxImage *arg1 = (wxImage *) 0 ;
12981 void *argp1 = 0 ;
12982 int res1 = 0 ;
12983 PyObject *swig_obj[1] ;
12984
12985 if (!args) SWIG_fail;
12986 swig_obj[0] = args;
12987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12988 if (!SWIG_IsOK(res1)) {
12989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12990 }
12991 arg1 = reinterpret_cast< wxImage * >(argp1);
12992 {
12993 PyThreadState* __tstate = wxPyBeginAllowThreads();
12994 delete arg1;
12995
12996 wxPyEndAllowThreads(__tstate);
12997 if (PyErr_Occurred()) SWIG_fail;
12998 }
12999 resultobj = SWIG_Py_Void();
13000 return resultobj;
13001 fail:
13002 return NULL;
13003 }
13004
13005
13006 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13007 PyObject *resultobj = 0;
13008 wxString *arg1 = 0 ;
13009 wxString *arg2 = 0 ;
13010 int arg3 = (int) -1 ;
13011 wxImage *result = 0 ;
13012 bool temp1 = false ;
13013 bool temp2 = false ;
13014 int val3 ;
13015 int ecode3 = 0 ;
13016 PyObject * obj0 = 0 ;
13017 PyObject * obj1 = 0 ;
13018 PyObject * obj2 = 0 ;
13019 char * kwnames[] = {
13020 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13021 };
13022
13023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13024 {
13025 arg1 = wxString_in_helper(obj0);
13026 if (arg1 == NULL) SWIG_fail;
13027 temp1 = true;
13028 }
13029 {
13030 arg2 = wxString_in_helper(obj1);
13031 if (arg2 == NULL) SWIG_fail;
13032 temp2 = true;
13033 }
13034 if (obj2) {
13035 ecode3 = SWIG_AsVal_int(obj2, &val3);
13036 if (!SWIG_IsOK(ecode3)) {
13037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13038 }
13039 arg3 = static_cast< int >(val3);
13040 }
13041 {
13042 PyThreadState* __tstate = wxPyBeginAllowThreads();
13043 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13044 wxPyEndAllowThreads(__tstate);
13045 if (PyErr_Occurred()) SWIG_fail;
13046 }
13047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13048 {
13049 if (temp1)
13050 delete arg1;
13051 }
13052 {
13053 if (temp2)
13054 delete arg2;
13055 }
13056 return resultobj;
13057 fail:
13058 {
13059 if (temp1)
13060 delete arg1;
13061 }
13062 {
13063 if (temp2)
13064 delete arg2;
13065 }
13066 return NULL;
13067 }
13068
13069
13070 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13071 PyObject *resultobj = 0;
13072 wxInputStream *arg1 = 0 ;
13073 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13074 int arg3 = (int) -1 ;
13075 wxImage *result = 0 ;
13076 wxPyInputStream *temp1 ;
13077 bool created1 ;
13078 long val2 ;
13079 int ecode2 = 0 ;
13080 int val3 ;
13081 int ecode3 = 0 ;
13082 PyObject * obj0 = 0 ;
13083 PyObject * obj1 = 0 ;
13084 PyObject * obj2 = 0 ;
13085 char * kwnames[] = {
13086 (char *) "stream",(char *) "type",(char *) "index", NULL
13087 };
13088
13089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13090 {
13091 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13092 arg1 = temp1->m_wxis;
13093 created1 = false;
13094 } else {
13095 PyErr_Clear(); // clear the failure of the wxPyConvert above
13096 arg1 = wxPyCBInputStream_create(obj0, false);
13097 if (arg1 == NULL) {
13098 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13099 SWIG_fail;
13100 }
13101 created1 = true;
13102 }
13103 }
13104 if (obj1) {
13105 ecode2 = SWIG_AsVal_long(obj1, &val2);
13106 if (!SWIG_IsOK(ecode2)) {
13107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13108 }
13109 arg2 = static_cast< long >(val2);
13110 }
13111 if (obj2) {
13112 ecode3 = SWIG_AsVal_int(obj2, &val3);
13113 if (!SWIG_IsOK(ecode3)) {
13114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13115 }
13116 arg3 = static_cast< int >(val3);
13117 }
13118 {
13119 PyThreadState* __tstate = wxPyBeginAllowThreads();
13120 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13121 wxPyEndAllowThreads(__tstate);
13122 if (PyErr_Occurred()) SWIG_fail;
13123 }
13124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13125 {
13126 if (created1) delete arg1;
13127 }
13128 return resultobj;
13129 fail:
13130 {
13131 if (created1) delete arg1;
13132 }
13133 return NULL;
13134 }
13135
13136
13137 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13138 PyObject *resultobj = 0;
13139 wxInputStream *arg1 = 0 ;
13140 wxString *arg2 = 0 ;
13141 int arg3 = (int) -1 ;
13142 wxImage *result = 0 ;
13143 wxPyInputStream *temp1 ;
13144 bool created1 ;
13145 bool temp2 = false ;
13146 int val3 ;
13147 int ecode3 = 0 ;
13148 PyObject * obj0 = 0 ;
13149 PyObject * obj1 = 0 ;
13150 PyObject * obj2 = 0 ;
13151 char * kwnames[] = {
13152 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13153 };
13154
13155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13156 {
13157 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13158 arg1 = temp1->m_wxis;
13159 created1 = false;
13160 } else {
13161 PyErr_Clear(); // clear the failure of the wxPyConvert above
13162 arg1 = wxPyCBInputStream_create(obj0, false);
13163 if (arg1 == NULL) {
13164 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13165 SWIG_fail;
13166 }
13167 created1 = true;
13168 }
13169 }
13170 {
13171 arg2 = wxString_in_helper(obj1);
13172 if (arg2 == NULL) SWIG_fail;
13173 temp2 = true;
13174 }
13175 if (obj2) {
13176 ecode3 = SWIG_AsVal_int(obj2, &val3);
13177 if (!SWIG_IsOK(ecode3)) {
13178 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13179 }
13180 arg3 = static_cast< int >(val3);
13181 }
13182 {
13183 PyThreadState* __tstate = wxPyBeginAllowThreads();
13184 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13185 wxPyEndAllowThreads(__tstate);
13186 if (PyErr_Occurred()) SWIG_fail;
13187 }
13188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13189 {
13190 if (created1) delete arg1;
13191 }
13192 {
13193 if (temp2)
13194 delete arg2;
13195 }
13196 return resultobj;
13197 fail:
13198 {
13199 if (created1) delete arg1;
13200 }
13201 {
13202 if (temp2)
13203 delete arg2;
13204 }
13205 return NULL;
13206 }
13207
13208
13209 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13210 PyObject *resultobj = 0;
13211 int arg1 = (int) 0 ;
13212 int arg2 = (int) 0 ;
13213 bool arg3 = (bool) true ;
13214 wxImage *result = 0 ;
13215 int val1 ;
13216 int ecode1 = 0 ;
13217 int val2 ;
13218 int ecode2 = 0 ;
13219 bool val3 ;
13220 int ecode3 = 0 ;
13221 PyObject * obj0 = 0 ;
13222 PyObject * obj1 = 0 ;
13223 PyObject * obj2 = 0 ;
13224 char * kwnames[] = {
13225 (char *) "width",(char *) "height",(char *) "clear", NULL
13226 };
13227
13228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13229 if (obj0) {
13230 ecode1 = SWIG_AsVal_int(obj0, &val1);
13231 if (!SWIG_IsOK(ecode1)) {
13232 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13233 }
13234 arg1 = static_cast< int >(val1);
13235 }
13236 if (obj1) {
13237 ecode2 = SWIG_AsVal_int(obj1, &val2);
13238 if (!SWIG_IsOK(ecode2)) {
13239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13240 }
13241 arg2 = static_cast< int >(val2);
13242 }
13243 if (obj2) {
13244 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13245 if (!SWIG_IsOK(ecode3)) {
13246 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13247 }
13248 arg3 = static_cast< bool >(val3);
13249 }
13250 {
13251 PyThreadState* __tstate = wxPyBeginAllowThreads();
13252 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13253 wxPyEndAllowThreads(__tstate);
13254 if (PyErr_Occurred()) SWIG_fail;
13255 }
13256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13257 return resultobj;
13258 fail:
13259 return NULL;
13260 }
13261
13262
13263 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13264 PyObject *resultobj = 0;
13265 wxBitmap *arg1 = 0 ;
13266 wxImage *result = 0 ;
13267 void *argp1 = 0 ;
13268 int res1 = 0 ;
13269 PyObject * obj0 = 0 ;
13270 char * kwnames[] = {
13271 (char *) "bitmap", NULL
13272 };
13273
13274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13275 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13276 if (!SWIG_IsOK(res1)) {
13277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13278 }
13279 if (!argp1) {
13280 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13281 }
13282 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13283 {
13284 if (!wxPyCheckForApp()) SWIG_fail;
13285 PyThreadState* __tstate = wxPyBeginAllowThreads();
13286 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13287 wxPyEndAllowThreads(__tstate);
13288 if (PyErr_Occurred()) SWIG_fail;
13289 }
13290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13291 return resultobj;
13292 fail:
13293 return NULL;
13294 }
13295
13296
13297 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13298 PyObject *resultobj = 0;
13299 int arg1 ;
13300 int arg2 ;
13301 buffer arg3 ;
13302 int arg4 ;
13303 wxImage *result = 0 ;
13304 int val1 ;
13305 int ecode1 = 0 ;
13306 int val2 ;
13307 int ecode2 = 0 ;
13308 PyObject * obj0 = 0 ;
13309 PyObject * obj1 = 0 ;
13310 PyObject * obj2 = 0 ;
13311 char * kwnames[] = {
13312 (char *) "width",(char *) "height",(char *) "data", NULL
13313 };
13314
13315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13316 ecode1 = SWIG_AsVal_int(obj0, &val1);
13317 if (!SWIG_IsOK(ecode1)) {
13318 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13319 }
13320 arg1 = static_cast< int >(val1);
13321 ecode2 = SWIG_AsVal_int(obj1, &val2);
13322 if (!SWIG_IsOK(ecode2)) {
13323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13324 }
13325 arg2 = static_cast< int >(val2);
13326 {
13327 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13328 }
13329 {
13330 PyThreadState* __tstate = wxPyBeginAllowThreads();
13331 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13332 wxPyEndAllowThreads(__tstate);
13333 if (PyErr_Occurred()) SWIG_fail;
13334 }
13335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13336 return resultobj;
13337 fail:
13338 return NULL;
13339 }
13340
13341
13342 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13343 PyObject *resultobj = 0;
13344 int arg1 ;
13345 int arg2 ;
13346 buffer arg3 ;
13347 int arg4 ;
13348 buffer arg5 ;
13349 int arg6 ;
13350 wxImage *result = 0 ;
13351 int val1 ;
13352 int ecode1 = 0 ;
13353 int val2 ;
13354 int ecode2 = 0 ;
13355 PyObject * obj0 = 0 ;
13356 PyObject * obj1 = 0 ;
13357 PyObject * obj2 = 0 ;
13358 PyObject * obj3 = 0 ;
13359 char * kwnames[] = {
13360 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13361 };
13362
13363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13364 ecode1 = SWIG_AsVal_int(obj0, &val1);
13365 if (!SWIG_IsOK(ecode1)) {
13366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13367 }
13368 arg1 = static_cast< int >(val1);
13369 ecode2 = SWIG_AsVal_int(obj1, &val2);
13370 if (!SWIG_IsOK(ecode2)) {
13371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13372 }
13373 arg2 = static_cast< int >(val2);
13374 {
13375 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13376 }
13377 {
13378 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13379 }
13380 {
13381 PyThreadState* __tstate = wxPyBeginAllowThreads();
13382 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13383 wxPyEndAllowThreads(__tstate);
13384 if (PyErr_Occurred()) SWIG_fail;
13385 }
13386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13387 return resultobj;
13388 fail:
13389 return NULL;
13390 }
13391
13392
13393 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13394 PyObject *resultobj = 0;
13395 wxImage *arg1 = (wxImage *) 0 ;
13396 int arg2 ;
13397 int arg3 ;
13398 bool arg4 = (bool) true ;
13399 void *argp1 = 0 ;
13400 int res1 = 0 ;
13401 int val2 ;
13402 int ecode2 = 0 ;
13403 int val3 ;
13404 int ecode3 = 0 ;
13405 bool val4 ;
13406 int ecode4 = 0 ;
13407 PyObject * obj0 = 0 ;
13408 PyObject * obj1 = 0 ;
13409 PyObject * obj2 = 0 ;
13410 PyObject * obj3 = 0 ;
13411 char * kwnames[] = {
13412 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13413 };
13414
13415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13417 if (!SWIG_IsOK(res1)) {
13418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13419 }
13420 arg1 = reinterpret_cast< wxImage * >(argp1);
13421 ecode2 = SWIG_AsVal_int(obj1, &val2);
13422 if (!SWIG_IsOK(ecode2)) {
13423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13424 }
13425 arg2 = static_cast< int >(val2);
13426 ecode3 = SWIG_AsVal_int(obj2, &val3);
13427 if (!SWIG_IsOK(ecode3)) {
13428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13429 }
13430 arg3 = static_cast< int >(val3);
13431 if (obj3) {
13432 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13433 if (!SWIG_IsOK(ecode4)) {
13434 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13435 }
13436 arg4 = static_cast< bool >(val4);
13437 }
13438 {
13439 PyThreadState* __tstate = wxPyBeginAllowThreads();
13440 (arg1)->Create(arg2,arg3,arg4);
13441 wxPyEndAllowThreads(__tstate);
13442 if (PyErr_Occurred()) SWIG_fail;
13443 }
13444 resultobj = SWIG_Py_Void();
13445 return resultobj;
13446 fail:
13447 return NULL;
13448 }
13449
13450
13451 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13452 PyObject *resultobj = 0;
13453 wxImage *arg1 = (wxImage *) 0 ;
13454 void *argp1 = 0 ;
13455 int res1 = 0 ;
13456 PyObject *swig_obj[1] ;
13457
13458 if (!args) SWIG_fail;
13459 swig_obj[0] = args;
13460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13461 if (!SWIG_IsOK(res1)) {
13462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13463 }
13464 arg1 = reinterpret_cast< wxImage * >(argp1);
13465 {
13466 PyThreadState* __tstate = wxPyBeginAllowThreads();
13467 (arg1)->Destroy();
13468 wxPyEndAllowThreads(__tstate);
13469 if (PyErr_Occurred()) SWIG_fail;
13470 }
13471 resultobj = SWIG_Py_Void();
13472 return resultobj;
13473 fail:
13474 return NULL;
13475 }
13476
13477
13478 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13479 PyObject *resultobj = 0;
13480 wxImage *arg1 = (wxImage *) 0 ;
13481 int arg2 ;
13482 int arg3 ;
13483 SwigValueWrapper<wxImage > result;
13484 void *argp1 = 0 ;
13485 int res1 = 0 ;
13486 int val2 ;
13487 int ecode2 = 0 ;
13488 int val3 ;
13489 int ecode3 = 0 ;
13490 PyObject * obj0 = 0 ;
13491 PyObject * obj1 = 0 ;
13492 PyObject * obj2 = 0 ;
13493 char * kwnames[] = {
13494 (char *) "self",(char *) "width",(char *) "height", NULL
13495 };
13496
13497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13499 if (!SWIG_IsOK(res1)) {
13500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13501 }
13502 arg1 = reinterpret_cast< wxImage * >(argp1);
13503 ecode2 = SWIG_AsVal_int(obj1, &val2);
13504 if (!SWIG_IsOK(ecode2)) {
13505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13506 }
13507 arg2 = static_cast< int >(val2);
13508 ecode3 = SWIG_AsVal_int(obj2, &val3);
13509 if (!SWIG_IsOK(ecode3)) {
13510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13511 }
13512 arg3 = static_cast< int >(val3);
13513 {
13514 PyThreadState* __tstate = wxPyBeginAllowThreads();
13515 result = (arg1)->Scale(arg2,arg3);
13516 wxPyEndAllowThreads(__tstate);
13517 if (PyErr_Occurred()) SWIG_fail;
13518 }
13519 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13520 return resultobj;
13521 fail:
13522 return NULL;
13523 }
13524
13525
13526 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13527 PyObject *resultobj = 0;
13528 wxImage *arg1 = (wxImage *) 0 ;
13529 int arg2 ;
13530 int arg3 ;
13531 SwigValueWrapper<wxImage > result;
13532 void *argp1 = 0 ;
13533 int res1 = 0 ;
13534 int val2 ;
13535 int ecode2 = 0 ;
13536 int val3 ;
13537 int ecode3 = 0 ;
13538 PyObject * obj0 = 0 ;
13539 PyObject * obj1 = 0 ;
13540 PyObject * obj2 = 0 ;
13541 char * kwnames[] = {
13542 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13543 };
13544
13545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13547 if (!SWIG_IsOK(res1)) {
13548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13549 }
13550 arg1 = reinterpret_cast< wxImage * >(argp1);
13551 ecode2 = SWIG_AsVal_int(obj1, &val2);
13552 if (!SWIG_IsOK(ecode2)) {
13553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13554 }
13555 arg2 = static_cast< int >(val2);
13556 ecode3 = SWIG_AsVal_int(obj2, &val3);
13557 if (!SWIG_IsOK(ecode3)) {
13558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13559 }
13560 arg3 = static_cast< int >(val3);
13561 {
13562 PyThreadState* __tstate = wxPyBeginAllowThreads();
13563 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13564 wxPyEndAllowThreads(__tstate);
13565 if (PyErr_Occurred()) SWIG_fail;
13566 }
13567 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13568 return resultobj;
13569 fail:
13570 return NULL;
13571 }
13572
13573
13574 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13575 PyObject *resultobj = 0;
13576 wxImage *arg1 = (wxImage *) 0 ;
13577 int arg2 ;
13578 int arg3 ;
13579 wxImage *result = 0 ;
13580 void *argp1 = 0 ;
13581 int res1 = 0 ;
13582 int val2 ;
13583 int ecode2 = 0 ;
13584 int val3 ;
13585 int ecode3 = 0 ;
13586 PyObject * obj0 = 0 ;
13587 PyObject * obj1 = 0 ;
13588 PyObject * obj2 = 0 ;
13589 char * kwnames[] = {
13590 (char *) "self",(char *) "width",(char *) "height", NULL
13591 };
13592
13593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13595 if (!SWIG_IsOK(res1)) {
13596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13597 }
13598 arg1 = reinterpret_cast< wxImage * >(argp1);
13599 ecode2 = SWIG_AsVal_int(obj1, &val2);
13600 if (!SWIG_IsOK(ecode2)) {
13601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13602 }
13603 arg2 = static_cast< int >(val2);
13604 ecode3 = SWIG_AsVal_int(obj2, &val3);
13605 if (!SWIG_IsOK(ecode3)) {
13606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13607 }
13608 arg3 = static_cast< int >(val3);
13609 {
13610 PyThreadState* __tstate = wxPyBeginAllowThreads();
13611 {
13612 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13613 result = (wxImage *) &_result_ref;
13614 }
13615 wxPyEndAllowThreads(__tstate);
13616 if (PyErr_Occurred()) SWIG_fail;
13617 }
13618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13619 return resultobj;
13620 fail:
13621 return NULL;
13622 }
13623
13624
13625 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13626 PyObject *resultobj = 0;
13627 wxImage *arg1 = (wxImage *) 0 ;
13628 wxSize *arg2 = 0 ;
13629 wxPoint *arg3 = 0 ;
13630 int arg4 = (int) -1 ;
13631 int arg5 = (int) -1 ;
13632 int arg6 = (int) -1 ;
13633 wxImage *result = 0 ;
13634 void *argp1 = 0 ;
13635 int res1 = 0 ;
13636 wxSize temp2 ;
13637 wxPoint temp3 ;
13638 int val4 ;
13639 int ecode4 = 0 ;
13640 int val5 ;
13641 int ecode5 = 0 ;
13642 int val6 ;
13643 int ecode6 = 0 ;
13644 PyObject * obj0 = 0 ;
13645 PyObject * obj1 = 0 ;
13646 PyObject * obj2 = 0 ;
13647 PyObject * obj3 = 0 ;
13648 PyObject * obj4 = 0 ;
13649 PyObject * obj5 = 0 ;
13650 char * kwnames[] = {
13651 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13652 };
13653
13654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13656 if (!SWIG_IsOK(res1)) {
13657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13658 }
13659 arg1 = reinterpret_cast< wxImage * >(argp1);
13660 {
13661 arg2 = &temp2;
13662 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13663 }
13664 {
13665 arg3 = &temp3;
13666 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13667 }
13668 if (obj3) {
13669 ecode4 = SWIG_AsVal_int(obj3, &val4);
13670 if (!SWIG_IsOK(ecode4)) {
13671 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13672 }
13673 arg4 = static_cast< int >(val4);
13674 }
13675 if (obj4) {
13676 ecode5 = SWIG_AsVal_int(obj4, &val5);
13677 if (!SWIG_IsOK(ecode5)) {
13678 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13679 }
13680 arg5 = static_cast< int >(val5);
13681 }
13682 if (obj5) {
13683 ecode6 = SWIG_AsVal_int(obj5, &val6);
13684 if (!SWIG_IsOK(ecode6)) {
13685 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13686 }
13687 arg6 = static_cast< int >(val6);
13688 }
13689 {
13690 PyThreadState* __tstate = wxPyBeginAllowThreads();
13691 {
13692 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13693 result = (wxImage *) &_result_ref;
13694 }
13695 wxPyEndAllowThreads(__tstate);
13696 if (PyErr_Occurred()) SWIG_fail;
13697 }
13698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13699 return resultobj;
13700 fail:
13701 return NULL;
13702 }
13703
13704
13705 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13706 PyObject *resultobj = 0;
13707 wxImage *arg1 = (wxImage *) 0 ;
13708 int arg2 ;
13709 int arg3 ;
13710 byte arg4 ;
13711 byte arg5 ;
13712 byte arg6 ;
13713 void *argp1 = 0 ;
13714 int res1 = 0 ;
13715 int val2 ;
13716 int ecode2 = 0 ;
13717 int val3 ;
13718 int ecode3 = 0 ;
13719 unsigned char val4 ;
13720 int ecode4 = 0 ;
13721 unsigned char val5 ;
13722 int ecode5 = 0 ;
13723 unsigned char val6 ;
13724 int ecode6 = 0 ;
13725 PyObject * obj0 = 0 ;
13726 PyObject * obj1 = 0 ;
13727 PyObject * obj2 = 0 ;
13728 PyObject * obj3 = 0 ;
13729 PyObject * obj4 = 0 ;
13730 PyObject * obj5 = 0 ;
13731 char * kwnames[] = {
13732 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13733 };
13734
13735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13737 if (!SWIG_IsOK(res1)) {
13738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13739 }
13740 arg1 = reinterpret_cast< wxImage * >(argp1);
13741 ecode2 = SWIG_AsVal_int(obj1, &val2);
13742 if (!SWIG_IsOK(ecode2)) {
13743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13744 }
13745 arg2 = static_cast< int >(val2);
13746 ecode3 = SWIG_AsVal_int(obj2, &val3);
13747 if (!SWIG_IsOK(ecode3)) {
13748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13749 }
13750 arg3 = static_cast< int >(val3);
13751 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13752 if (!SWIG_IsOK(ecode4)) {
13753 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13754 }
13755 arg4 = static_cast< byte >(val4);
13756 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13757 if (!SWIG_IsOK(ecode5)) {
13758 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13759 }
13760 arg5 = static_cast< byte >(val5);
13761 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13762 if (!SWIG_IsOK(ecode6)) {
13763 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13764 }
13765 arg6 = static_cast< byte >(val6);
13766 {
13767 PyThreadState* __tstate = wxPyBeginAllowThreads();
13768 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13769 wxPyEndAllowThreads(__tstate);
13770 if (PyErr_Occurred()) SWIG_fail;
13771 }
13772 resultobj = SWIG_Py_Void();
13773 return resultobj;
13774 fail:
13775 return NULL;
13776 }
13777
13778
13779 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13780 PyObject *resultobj = 0;
13781 wxImage *arg1 = (wxImage *) 0 ;
13782 wxRect *arg2 = 0 ;
13783 byte arg3 ;
13784 byte arg4 ;
13785 byte arg5 ;
13786 void *argp1 = 0 ;
13787 int res1 = 0 ;
13788 wxRect temp2 ;
13789 unsigned char val3 ;
13790 int ecode3 = 0 ;
13791 unsigned char val4 ;
13792 int ecode4 = 0 ;
13793 unsigned char val5 ;
13794 int ecode5 = 0 ;
13795 PyObject * obj0 = 0 ;
13796 PyObject * obj1 = 0 ;
13797 PyObject * obj2 = 0 ;
13798 PyObject * obj3 = 0 ;
13799 PyObject * obj4 = 0 ;
13800 char * kwnames[] = {
13801 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13802 };
13803
13804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13806 if (!SWIG_IsOK(res1)) {
13807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13808 }
13809 arg1 = reinterpret_cast< wxImage * >(argp1);
13810 {
13811 arg2 = &temp2;
13812 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13813 }
13814 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13815 if (!SWIG_IsOK(ecode3)) {
13816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13817 }
13818 arg3 = static_cast< byte >(val3);
13819 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13820 if (!SWIG_IsOK(ecode4)) {
13821 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13822 }
13823 arg4 = static_cast< byte >(val4);
13824 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13825 if (!SWIG_IsOK(ecode5)) {
13826 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13827 }
13828 arg5 = static_cast< byte >(val5);
13829 {
13830 PyThreadState* __tstate = wxPyBeginAllowThreads();
13831 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13832 wxPyEndAllowThreads(__tstate);
13833 if (PyErr_Occurred()) SWIG_fail;
13834 }
13835 resultobj = SWIG_Py_Void();
13836 return resultobj;
13837 fail:
13838 return NULL;
13839 }
13840
13841
13842 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13843 PyObject *resultobj = 0;
13844 wxImage *arg1 = (wxImage *) 0 ;
13845 int arg2 ;
13846 int arg3 ;
13847 byte result;
13848 void *argp1 = 0 ;
13849 int res1 = 0 ;
13850 int val2 ;
13851 int ecode2 = 0 ;
13852 int val3 ;
13853 int ecode3 = 0 ;
13854 PyObject * obj0 = 0 ;
13855 PyObject * obj1 = 0 ;
13856 PyObject * obj2 = 0 ;
13857 char * kwnames[] = {
13858 (char *) "self",(char *) "x",(char *) "y", NULL
13859 };
13860
13861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13863 if (!SWIG_IsOK(res1)) {
13864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13865 }
13866 arg1 = reinterpret_cast< wxImage * >(argp1);
13867 ecode2 = SWIG_AsVal_int(obj1, &val2);
13868 if (!SWIG_IsOK(ecode2)) {
13869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13870 }
13871 arg2 = static_cast< int >(val2);
13872 ecode3 = SWIG_AsVal_int(obj2, &val3);
13873 if (!SWIG_IsOK(ecode3)) {
13874 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13875 }
13876 arg3 = static_cast< int >(val3);
13877 {
13878 PyThreadState* __tstate = wxPyBeginAllowThreads();
13879 result = (byte)(arg1)->GetRed(arg2,arg3);
13880 wxPyEndAllowThreads(__tstate);
13881 if (PyErr_Occurred()) SWIG_fail;
13882 }
13883 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13884 return resultobj;
13885 fail:
13886 return NULL;
13887 }
13888
13889
13890 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13891 PyObject *resultobj = 0;
13892 wxImage *arg1 = (wxImage *) 0 ;
13893 int arg2 ;
13894 int arg3 ;
13895 byte result;
13896 void *argp1 = 0 ;
13897 int res1 = 0 ;
13898 int val2 ;
13899 int ecode2 = 0 ;
13900 int val3 ;
13901 int ecode3 = 0 ;
13902 PyObject * obj0 = 0 ;
13903 PyObject * obj1 = 0 ;
13904 PyObject * obj2 = 0 ;
13905 char * kwnames[] = {
13906 (char *) "self",(char *) "x",(char *) "y", NULL
13907 };
13908
13909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13911 if (!SWIG_IsOK(res1)) {
13912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13913 }
13914 arg1 = reinterpret_cast< wxImage * >(argp1);
13915 ecode2 = SWIG_AsVal_int(obj1, &val2);
13916 if (!SWIG_IsOK(ecode2)) {
13917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13918 }
13919 arg2 = static_cast< int >(val2);
13920 ecode3 = SWIG_AsVal_int(obj2, &val3);
13921 if (!SWIG_IsOK(ecode3)) {
13922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13923 }
13924 arg3 = static_cast< int >(val3);
13925 {
13926 PyThreadState* __tstate = wxPyBeginAllowThreads();
13927 result = (byte)(arg1)->GetGreen(arg2,arg3);
13928 wxPyEndAllowThreads(__tstate);
13929 if (PyErr_Occurred()) SWIG_fail;
13930 }
13931 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13932 return resultobj;
13933 fail:
13934 return NULL;
13935 }
13936
13937
13938 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13939 PyObject *resultobj = 0;
13940 wxImage *arg1 = (wxImage *) 0 ;
13941 int arg2 ;
13942 int arg3 ;
13943 byte result;
13944 void *argp1 = 0 ;
13945 int res1 = 0 ;
13946 int val2 ;
13947 int ecode2 = 0 ;
13948 int val3 ;
13949 int ecode3 = 0 ;
13950 PyObject * obj0 = 0 ;
13951 PyObject * obj1 = 0 ;
13952 PyObject * obj2 = 0 ;
13953 char * kwnames[] = {
13954 (char *) "self",(char *) "x",(char *) "y", NULL
13955 };
13956
13957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13959 if (!SWIG_IsOK(res1)) {
13960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13961 }
13962 arg1 = reinterpret_cast< wxImage * >(argp1);
13963 ecode2 = SWIG_AsVal_int(obj1, &val2);
13964 if (!SWIG_IsOK(ecode2)) {
13965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13966 }
13967 arg2 = static_cast< int >(val2);
13968 ecode3 = SWIG_AsVal_int(obj2, &val3);
13969 if (!SWIG_IsOK(ecode3)) {
13970 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13971 }
13972 arg3 = static_cast< int >(val3);
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 result = (byte)(arg1)->GetBlue(arg2,arg3);
13976 wxPyEndAllowThreads(__tstate);
13977 if (PyErr_Occurred()) SWIG_fail;
13978 }
13979 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13980 return resultobj;
13981 fail:
13982 return NULL;
13983 }
13984
13985
13986 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13987 PyObject *resultobj = 0;
13988 wxImage *arg1 = (wxImage *) 0 ;
13989 int arg2 ;
13990 int arg3 ;
13991 byte arg4 ;
13992 void *argp1 = 0 ;
13993 int res1 = 0 ;
13994 int val2 ;
13995 int ecode2 = 0 ;
13996 int val3 ;
13997 int ecode3 = 0 ;
13998 unsigned char val4 ;
13999 int ecode4 = 0 ;
14000 PyObject * obj0 = 0 ;
14001 PyObject * obj1 = 0 ;
14002 PyObject * obj2 = 0 ;
14003 PyObject * obj3 = 0 ;
14004 char * kwnames[] = {
14005 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14006 };
14007
14008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14010 if (!SWIG_IsOK(res1)) {
14011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14012 }
14013 arg1 = reinterpret_cast< wxImage * >(argp1);
14014 ecode2 = SWIG_AsVal_int(obj1, &val2);
14015 if (!SWIG_IsOK(ecode2)) {
14016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14017 }
14018 arg2 = static_cast< int >(val2);
14019 ecode3 = SWIG_AsVal_int(obj2, &val3);
14020 if (!SWIG_IsOK(ecode3)) {
14021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14022 }
14023 arg3 = static_cast< int >(val3);
14024 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14025 if (!SWIG_IsOK(ecode4)) {
14026 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14027 }
14028 arg4 = static_cast< byte >(val4);
14029 {
14030 PyThreadState* __tstate = wxPyBeginAllowThreads();
14031 (arg1)->SetAlpha(arg2,arg3,arg4);
14032 wxPyEndAllowThreads(__tstate);
14033 if (PyErr_Occurred()) SWIG_fail;
14034 }
14035 resultobj = SWIG_Py_Void();
14036 return resultobj;
14037 fail:
14038 return NULL;
14039 }
14040
14041
14042 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14043 PyObject *resultobj = 0;
14044 wxImage *arg1 = (wxImage *) 0 ;
14045 int arg2 ;
14046 int arg3 ;
14047 byte result;
14048 void *argp1 = 0 ;
14049 int res1 = 0 ;
14050 int val2 ;
14051 int ecode2 = 0 ;
14052 int val3 ;
14053 int ecode3 = 0 ;
14054 PyObject * obj0 = 0 ;
14055 PyObject * obj1 = 0 ;
14056 PyObject * obj2 = 0 ;
14057 char * kwnames[] = {
14058 (char *) "self",(char *) "x",(char *) "y", NULL
14059 };
14060
14061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14063 if (!SWIG_IsOK(res1)) {
14064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14065 }
14066 arg1 = reinterpret_cast< wxImage * >(argp1);
14067 ecode2 = SWIG_AsVal_int(obj1, &val2);
14068 if (!SWIG_IsOK(ecode2)) {
14069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14070 }
14071 arg2 = static_cast< int >(val2);
14072 ecode3 = SWIG_AsVal_int(obj2, &val3);
14073 if (!SWIG_IsOK(ecode3)) {
14074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14075 }
14076 arg3 = static_cast< int >(val3);
14077 {
14078 PyThreadState* __tstate = wxPyBeginAllowThreads();
14079 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14080 wxPyEndAllowThreads(__tstate);
14081 if (PyErr_Occurred()) SWIG_fail;
14082 }
14083 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14084 return resultobj;
14085 fail:
14086 return NULL;
14087 }
14088
14089
14090 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14091 PyObject *resultobj = 0;
14092 wxImage *arg1 = (wxImage *) 0 ;
14093 bool result;
14094 void *argp1 = 0 ;
14095 int res1 = 0 ;
14096 PyObject *swig_obj[1] ;
14097
14098 if (!args) SWIG_fail;
14099 swig_obj[0] = args;
14100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14101 if (!SWIG_IsOK(res1)) {
14102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14103 }
14104 arg1 = reinterpret_cast< wxImage * >(argp1);
14105 {
14106 PyThreadState* __tstate = wxPyBeginAllowThreads();
14107 result = (bool)(arg1)->HasAlpha();
14108 wxPyEndAllowThreads(__tstate);
14109 if (PyErr_Occurred()) SWIG_fail;
14110 }
14111 {
14112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14113 }
14114 return resultobj;
14115 fail:
14116 return NULL;
14117 }
14118
14119
14120 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14121 PyObject *resultobj = 0;
14122 wxImage *arg1 = (wxImage *) 0 ;
14123 void *argp1 = 0 ;
14124 int res1 = 0 ;
14125 PyObject *swig_obj[1] ;
14126
14127 if (!args) SWIG_fail;
14128 swig_obj[0] = args;
14129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14130 if (!SWIG_IsOK(res1)) {
14131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14132 }
14133 arg1 = reinterpret_cast< wxImage * >(argp1);
14134 {
14135 PyThreadState* __tstate = wxPyBeginAllowThreads();
14136 (arg1)->InitAlpha();
14137 wxPyEndAllowThreads(__tstate);
14138 if (PyErr_Occurred()) SWIG_fail;
14139 }
14140 resultobj = SWIG_Py_Void();
14141 return resultobj;
14142 fail:
14143 return NULL;
14144 }
14145
14146
14147 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14148 PyObject *resultobj = 0;
14149 wxImage *arg1 = (wxImage *) 0 ;
14150 int arg2 ;
14151 int arg3 ;
14152 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14153 bool result;
14154 void *argp1 = 0 ;
14155 int res1 = 0 ;
14156 int val2 ;
14157 int ecode2 = 0 ;
14158 int val3 ;
14159 int ecode3 = 0 ;
14160 unsigned char val4 ;
14161 int ecode4 = 0 ;
14162 PyObject * obj0 = 0 ;
14163 PyObject * obj1 = 0 ;
14164 PyObject * obj2 = 0 ;
14165 PyObject * obj3 = 0 ;
14166 char * kwnames[] = {
14167 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14168 };
14169
14170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14172 if (!SWIG_IsOK(res1)) {
14173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14174 }
14175 arg1 = reinterpret_cast< wxImage * >(argp1);
14176 ecode2 = SWIG_AsVal_int(obj1, &val2);
14177 if (!SWIG_IsOK(ecode2)) {
14178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14179 }
14180 arg2 = static_cast< int >(val2);
14181 ecode3 = SWIG_AsVal_int(obj2, &val3);
14182 if (!SWIG_IsOK(ecode3)) {
14183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14184 }
14185 arg3 = static_cast< int >(val3);
14186 if (obj3) {
14187 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14188 if (!SWIG_IsOK(ecode4)) {
14189 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14190 }
14191 arg4 = static_cast< byte >(val4);
14192 }
14193 {
14194 PyThreadState* __tstate = wxPyBeginAllowThreads();
14195 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14196 wxPyEndAllowThreads(__tstate);
14197 if (PyErr_Occurred()) SWIG_fail;
14198 }
14199 {
14200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14201 }
14202 return resultobj;
14203 fail:
14204 return NULL;
14205 }
14206
14207
14208 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14209 PyObject *resultobj = 0;
14210 wxImage *arg1 = (wxImage *) 0 ;
14211 byte *arg2 = (byte *) 0 ;
14212 byte *arg3 = (byte *) 0 ;
14213 byte *arg4 = (byte *) 0 ;
14214 byte arg5 = (byte) 0 ;
14215 byte arg6 = (byte) 0 ;
14216 byte arg7 = (byte) 0 ;
14217 bool result;
14218 void *argp1 = 0 ;
14219 int res1 = 0 ;
14220 byte temp2 ;
14221 int res2 = SWIG_TMPOBJ ;
14222 byte temp3 ;
14223 int res3 = SWIG_TMPOBJ ;
14224 byte temp4 ;
14225 int res4 = SWIG_TMPOBJ ;
14226 unsigned char val5 ;
14227 int ecode5 = 0 ;
14228 unsigned char val6 ;
14229 int ecode6 = 0 ;
14230 unsigned char val7 ;
14231 int ecode7 = 0 ;
14232 PyObject * obj0 = 0 ;
14233 PyObject * obj1 = 0 ;
14234 PyObject * obj2 = 0 ;
14235 PyObject * obj3 = 0 ;
14236 char * kwnames[] = {
14237 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14238 };
14239
14240 arg2 = &temp2;
14241 arg3 = &temp3;
14242 arg4 = &temp4;
14243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14245 if (!SWIG_IsOK(res1)) {
14246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14247 }
14248 arg1 = reinterpret_cast< wxImage * >(argp1);
14249 if (obj1) {
14250 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14251 if (!SWIG_IsOK(ecode5)) {
14252 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14253 }
14254 arg5 = static_cast< byte >(val5);
14255 }
14256 if (obj2) {
14257 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14258 if (!SWIG_IsOK(ecode6)) {
14259 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14260 }
14261 arg6 = static_cast< byte >(val6);
14262 }
14263 if (obj3) {
14264 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14265 if (!SWIG_IsOK(ecode7)) {
14266 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14267 }
14268 arg7 = static_cast< byte >(val7);
14269 }
14270 {
14271 PyThreadState* __tstate = wxPyBeginAllowThreads();
14272 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14273 wxPyEndAllowThreads(__tstate);
14274 if (PyErr_Occurred()) SWIG_fail;
14275 }
14276 {
14277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14278 }
14279 if (SWIG_IsTmpObj(res2)) {
14280 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14281 } else {
14282 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14283 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14284 }
14285 if (SWIG_IsTmpObj(res3)) {
14286 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14287 } else {
14288 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14289 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14290 }
14291 if (SWIG_IsTmpObj(res4)) {
14292 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14293 } else {
14294 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14295 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14296 }
14297 return resultobj;
14298 fail:
14299 return NULL;
14300 }
14301
14302
14303 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14304 PyObject *resultobj = 0;
14305 wxImage *arg1 = (wxImage *) 0 ;
14306 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14307 bool result;
14308 void *argp1 = 0 ;
14309 int res1 = 0 ;
14310 unsigned char val2 ;
14311 int ecode2 = 0 ;
14312 PyObject * obj0 = 0 ;
14313 PyObject * obj1 = 0 ;
14314 char * kwnames[] = {
14315 (char *) "self",(char *) "threshold", NULL
14316 };
14317
14318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14320 if (!SWIG_IsOK(res1)) {
14321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14322 }
14323 arg1 = reinterpret_cast< wxImage * >(argp1);
14324 if (obj1) {
14325 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14326 if (!SWIG_IsOK(ecode2)) {
14327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14328 }
14329 arg2 = static_cast< byte >(val2);
14330 }
14331 {
14332 PyThreadState* __tstate = wxPyBeginAllowThreads();
14333 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14334 wxPyEndAllowThreads(__tstate);
14335 if (PyErr_Occurred()) SWIG_fail;
14336 }
14337 {
14338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14339 }
14340 return resultobj;
14341 fail:
14342 return NULL;
14343 }
14344
14345
14346 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14347 PyObject *resultobj = 0;
14348 wxImage *arg1 = (wxImage *) 0 ;
14349 byte arg2 ;
14350 byte arg3 ;
14351 byte arg4 ;
14352 bool result;
14353 void *argp1 = 0 ;
14354 int res1 = 0 ;
14355 unsigned char val2 ;
14356 int ecode2 = 0 ;
14357 unsigned char val3 ;
14358 int ecode3 = 0 ;
14359 unsigned char val4 ;
14360 int ecode4 = 0 ;
14361 PyObject * obj0 = 0 ;
14362 PyObject * obj1 = 0 ;
14363 PyObject * obj2 = 0 ;
14364 PyObject * obj3 = 0 ;
14365 char * kwnames[] = {
14366 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14367 };
14368
14369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14371 if (!SWIG_IsOK(res1)) {
14372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14373 }
14374 arg1 = reinterpret_cast< wxImage * >(argp1);
14375 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14376 if (!SWIG_IsOK(ecode2)) {
14377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14378 }
14379 arg2 = static_cast< byte >(val2);
14380 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14381 if (!SWIG_IsOK(ecode3)) {
14382 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14383 }
14384 arg3 = static_cast< byte >(val3);
14385 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14386 if (!SWIG_IsOK(ecode4)) {
14387 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14388 }
14389 arg4 = static_cast< byte >(val4);
14390 {
14391 PyThreadState* __tstate = wxPyBeginAllowThreads();
14392 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14393 wxPyEndAllowThreads(__tstate);
14394 if (PyErr_Occurred()) SWIG_fail;
14395 }
14396 {
14397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14398 }
14399 return resultobj;
14400 fail:
14401 return NULL;
14402 }
14403
14404
14405 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14406 PyObject *resultobj = 0;
14407 wxImage *arg1 = (wxImage *) 0 ;
14408 wxImage *arg2 = 0 ;
14409 byte arg3 ;
14410 byte arg4 ;
14411 byte arg5 ;
14412 bool result;
14413 void *argp1 = 0 ;
14414 int res1 = 0 ;
14415 void *argp2 = 0 ;
14416 int res2 = 0 ;
14417 unsigned char val3 ;
14418 int ecode3 = 0 ;
14419 unsigned char val4 ;
14420 int ecode4 = 0 ;
14421 unsigned char val5 ;
14422 int ecode5 = 0 ;
14423 PyObject * obj0 = 0 ;
14424 PyObject * obj1 = 0 ;
14425 PyObject * obj2 = 0 ;
14426 PyObject * obj3 = 0 ;
14427 PyObject * obj4 = 0 ;
14428 char * kwnames[] = {
14429 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14430 };
14431
14432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14434 if (!SWIG_IsOK(res1)) {
14435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14436 }
14437 arg1 = reinterpret_cast< wxImage * >(argp1);
14438 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14439 if (!SWIG_IsOK(res2)) {
14440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14441 }
14442 if (!argp2) {
14443 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14444 }
14445 arg2 = reinterpret_cast< wxImage * >(argp2);
14446 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14447 if (!SWIG_IsOK(ecode3)) {
14448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14449 }
14450 arg3 = static_cast< byte >(val3);
14451 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14452 if (!SWIG_IsOK(ecode4)) {
14453 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14454 }
14455 arg4 = static_cast< byte >(val4);
14456 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14457 if (!SWIG_IsOK(ecode5)) {
14458 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14459 }
14460 arg5 = static_cast< byte >(val5);
14461 {
14462 PyThreadState* __tstate = wxPyBeginAllowThreads();
14463 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14464 wxPyEndAllowThreads(__tstate);
14465 if (PyErr_Occurred()) SWIG_fail;
14466 }
14467 {
14468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14469 }
14470 return resultobj;
14471 fail:
14472 return NULL;
14473 }
14474
14475
14476 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14477 PyObject *resultobj = 0;
14478 wxString *arg1 = 0 ;
14479 bool result;
14480 bool temp1 = false ;
14481 PyObject * obj0 = 0 ;
14482 char * kwnames[] = {
14483 (char *) "filename", NULL
14484 };
14485
14486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14487 {
14488 arg1 = wxString_in_helper(obj0);
14489 if (arg1 == NULL) SWIG_fail;
14490 temp1 = true;
14491 }
14492 {
14493 PyThreadState* __tstate = wxPyBeginAllowThreads();
14494 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 {
14499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14500 }
14501 {
14502 if (temp1)
14503 delete arg1;
14504 }
14505 return resultobj;
14506 fail:
14507 {
14508 if (temp1)
14509 delete arg1;
14510 }
14511 return NULL;
14512 }
14513
14514
14515 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14516 PyObject *resultobj = 0;
14517 wxString *arg1 = 0 ;
14518 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14519 int result;
14520 bool temp1 = false ;
14521 long val2 ;
14522 int ecode2 = 0 ;
14523 PyObject * obj0 = 0 ;
14524 PyObject * obj1 = 0 ;
14525 char * kwnames[] = {
14526 (char *) "filename",(char *) "type", NULL
14527 };
14528
14529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14530 {
14531 arg1 = wxString_in_helper(obj0);
14532 if (arg1 == NULL) SWIG_fail;
14533 temp1 = true;
14534 }
14535 if (obj1) {
14536 ecode2 = SWIG_AsVal_long(obj1, &val2);
14537 if (!SWIG_IsOK(ecode2)) {
14538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14539 }
14540 arg2 = static_cast< long >(val2);
14541 }
14542 {
14543 PyThreadState* __tstate = wxPyBeginAllowThreads();
14544 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14545 wxPyEndAllowThreads(__tstate);
14546 if (PyErr_Occurred()) SWIG_fail;
14547 }
14548 resultobj = SWIG_From_int(static_cast< int >(result));
14549 {
14550 if (temp1)
14551 delete arg1;
14552 }
14553 return resultobj;
14554 fail:
14555 {
14556 if (temp1)
14557 delete arg1;
14558 }
14559 return NULL;
14560 }
14561
14562
14563 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14564 PyObject *resultobj = 0;
14565 wxImage *arg1 = (wxImage *) 0 ;
14566 wxString *arg2 = 0 ;
14567 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14568 int arg4 = (int) -1 ;
14569 bool result;
14570 void *argp1 = 0 ;
14571 int res1 = 0 ;
14572 bool temp2 = false ;
14573 long val3 ;
14574 int ecode3 = 0 ;
14575 int val4 ;
14576 int ecode4 = 0 ;
14577 PyObject * obj0 = 0 ;
14578 PyObject * obj1 = 0 ;
14579 PyObject * obj2 = 0 ;
14580 PyObject * obj3 = 0 ;
14581 char * kwnames[] = {
14582 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14583 };
14584
14585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14587 if (!SWIG_IsOK(res1)) {
14588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14589 }
14590 arg1 = reinterpret_cast< wxImage * >(argp1);
14591 {
14592 arg2 = wxString_in_helper(obj1);
14593 if (arg2 == NULL) SWIG_fail;
14594 temp2 = true;
14595 }
14596 if (obj2) {
14597 ecode3 = SWIG_AsVal_long(obj2, &val3);
14598 if (!SWIG_IsOK(ecode3)) {
14599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14600 }
14601 arg3 = static_cast< long >(val3);
14602 }
14603 if (obj3) {
14604 ecode4 = SWIG_AsVal_int(obj3, &val4);
14605 if (!SWIG_IsOK(ecode4)) {
14606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14607 }
14608 arg4 = static_cast< int >(val4);
14609 }
14610 {
14611 PyThreadState* __tstate = wxPyBeginAllowThreads();
14612 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14613 wxPyEndAllowThreads(__tstate);
14614 if (PyErr_Occurred()) SWIG_fail;
14615 }
14616 {
14617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14618 }
14619 {
14620 if (temp2)
14621 delete arg2;
14622 }
14623 return resultobj;
14624 fail:
14625 {
14626 if (temp2)
14627 delete arg2;
14628 }
14629 return NULL;
14630 }
14631
14632
14633 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14634 PyObject *resultobj = 0;
14635 wxImage *arg1 = (wxImage *) 0 ;
14636 wxString *arg2 = 0 ;
14637 wxString *arg3 = 0 ;
14638 int arg4 = (int) -1 ;
14639 bool result;
14640 void *argp1 = 0 ;
14641 int res1 = 0 ;
14642 bool temp2 = false ;
14643 bool temp3 = false ;
14644 int val4 ;
14645 int ecode4 = 0 ;
14646 PyObject * obj0 = 0 ;
14647 PyObject * obj1 = 0 ;
14648 PyObject * obj2 = 0 ;
14649 PyObject * obj3 = 0 ;
14650 char * kwnames[] = {
14651 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14652 };
14653
14654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14656 if (!SWIG_IsOK(res1)) {
14657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14658 }
14659 arg1 = reinterpret_cast< wxImage * >(argp1);
14660 {
14661 arg2 = wxString_in_helper(obj1);
14662 if (arg2 == NULL) SWIG_fail;
14663 temp2 = true;
14664 }
14665 {
14666 arg3 = wxString_in_helper(obj2);
14667 if (arg3 == NULL) SWIG_fail;
14668 temp3 = true;
14669 }
14670 if (obj3) {
14671 ecode4 = SWIG_AsVal_int(obj3, &val4);
14672 if (!SWIG_IsOK(ecode4)) {
14673 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14674 }
14675 arg4 = static_cast< int >(val4);
14676 }
14677 {
14678 PyThreadState* __tstate = wxPyBeginAllowThreads();
14679 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14680 wxPyEndAllowThreads(__tstate);
14681 if (PyErr_Occurred()) SWIG_fail;
14682 }
14683 {
14684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14685 }
14686 {
14687 if (temp2)
14688 delete arg2;
14689 }
14690 {
14691 if (temp3)
14692 delete arg3;
14693 }
14694 return resultobj;
14695 fail:
14696 {
14697 if (temp2)
14698 delete arg2;
14699 }
14700 {
14701 if (temp3)
14702 delete arg3;
14703 }
14704 return NULL;
14705 }
14706
14707
14708 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14709 PyObject *resultobj = 0;
14710 wxImage *arg1 = (wxImage *) 0 ;
14711 wxString *arg2 = 0 ;
14712 int arg3 ;
14713 bool result;
14714 void *argp1 = 0 ;
14715 int res1 = 0 ;
14716 bool temp2 = false ;
14717 int val3 ;
14718 int ecode3 = 0 ;
14719 PyObject * obj0 = 0 ;
14720 PyObject * obj1 = 0 ;
14721 PyObject * obj2 = 0 ;
14722 char * kwnames[] = {
14723 (char *) "self",(char *) "name",(char *) "type", NULL
14724 };
14725
14726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14728 if (!SWIG_IsOK(res1)) {
14729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14730 }
14731 arg1 = reinterpret_cast< wxImage * >(argp1);
14732 {
14733 arg2 = wxString_in_helper(obj1);
14734 if (arg2 == NULL) SWIG_fail;
14735 temp2 = true;
14736 }
14737 ecode3 = SWIG_AsVal_int(obj2, &val3);
14738 if (!SWIG_IsOK(ecode3)) {
14739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14740 }
14741 arg3 = static_cast< int >(val3);
14742 {
14743 PyThreadState* __tstate = wxPyBeginAllowThreads();
14744 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14745 wxPyEndAllowThreads(__tstate);
14746 if (PyErr_Occurred()) SWIG_fail;
14747 }
14748 {
14749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14750 }
14751 {
14752 if (temp2)
14753 delete arg2;
14754 }
14755 return resultobj;
14756 fail:
14757 {
14758 if (temp2)
14759 delete arg2;
14760 }
14761 return NULL;
14762 }
14763
14764
14765 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14766 PyObject *resultobj = 0;
14767 wxImage *arg1 = (wxImage *) 0 ;
14768 wxString *arg2 = 0 ;
14769 wxString *arg3 = 0 ;
14770 bool result;
14771 void *argp1 = 0 ;
14772 int res1 = 0 ;
14773 bool temp2 = false ;
14774 bool temp3 = false ;
14775 PyObject * obj0 = 0 ;
14776 PyObject * obj1 = 0 ;
14777 PyObject * obj2 = 0 ;
14778 char * kwnames[] = {
14779 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14780 };
14781
14782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14784 if (!SWIG_IsOK(res1)) {
14785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14786 }
14787 arg1 = reinterpret_cast< wxImage * >(argp1);
14788 {
14789 arg2 = wxString_in_helper(obj1);
14790 if (arg2 == NULL) SWIG_fail;
14791 temp2 = true;
14792 }
14793 {
14794 arg3 = wxString_in_helper(obj2);
14795 if (arg3 == NULL) SWIG_fail;
14796 temp3 = true;
14797 }
14798 {
14799 PyThreadState* __tstate = wxPyBeginAllowThreads();
14800 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14801 wxPyEndAllowThreads(__tstate);
14802 if (PyErr_Occurred()) SWIG_fail;
14803 }
14804 {
14805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14806 }
14807 {
14808 if (temp2)
14809 delete arg2;
14810 }
14811 {
14812 if (temp3)
14813 delete arg3;
14814 }
14815 return resultobj;
14816 fail:
14817 {
14818 if (temp2)
14819 delete arg2;
14820 }
14821 {
14822 if (temp3)
14823 delete arg3;
14824 }
14825 return NULL;
14826 }
14827
14828
14829 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14830 PyObject *resultobj = 0;
14831 wxInputStream *arg1 = 0 ;
14832 bool result;
14833 wxPyInputStream *temp1 ;
14834 bool created1 ;
14835 PyObject * obj0 = 0 ;
14836 char * kwnames[] = {
14837 (char *) "stream", NULL
14838 };
14839
14840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14841 {
14842 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14843 arg1 = temp1->m_wxis;
14844 created1 = false;
14845 } else {
14846 PyErr_Clear(); // clear the failure of the wxPyConvert above
14847 arg1 = wxPyCBInputStream_create(obj0, false);
14848 if (arg1 == NULL) {
14849 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14850 SWIG_fail;
14851 }
14852 created1 = true;
14853 }
14854 }
14855 {
14856 PyThreadState* __tstate = wxPyBeginAllowThreads();
14857 result = (bool)wxImage::CanRead(*arg1);
14858 wxPyEndAllowThreads(__tstate);
14859 if (PyErr_Occurred()) SWIG_fail;
14860 }
14861 {
14862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14863 }
14864 {
14865 if (created1) delete arg1;
14866 }
14867 return resultobj;
14868 fail:
14869 {
14870 if (created1) delete arg1;
14871 }
14872 return NULL;
14873 }
14874
14875
14876 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14877 PyObject *resultobj = 0;
14878 wxImage *arg1 = (wxImage *) 0 ;
14879 wxInputStream *arg2 = 0 ;
14880 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14881 int arg4 = (int) -1 ;
14882 bool result;
14883 void *argp1 = 0 ;
14884 int res1 = 0 ;
14885 wxPyInputStream *temp2 ;
14886 bool created2 ;
14887 long val3 ;
14888 int ecode3 = 0 ;
14889 int val4 ;
14890 int ecode4 = 0 ;
14891 PyObject * obj0 = 0 ;
14892 PyObject * obj1 = 0 ;
14893 PyObject * obj2 = 0 ;
14894 PyObject * obj3 = 0 ;
14895 char * kwnames[] = {
14896 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14897 };
14898
14899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14901 if (!SWIG_IsOK(res1)) {
14902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14903 }
14904 arg1 = reinterpret_cast< wxImage * >(argp1);
14905 {
14906 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14907 arg2 = temp2->m_wxis;
14908 created2 = false;
14909 } else {
14910 PyErr_Clear(); // clear the failure of the wxPyConvert above
14911 arg2 = wxPyCBInputStream_create(obj1, false);
14912 if (arg2 == NULL) {
14913 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14914 SWIG_fail;
14915 }
14916 created2 = true;
14917 }
14918 }
14919 if (obj2) {
14920 ecode3 = SWIG_AsVal_long(obj2, &val3);
14921 if (!SWIG_IsOK(ecode3)) {
14922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14923 }
14924 arg3 = static_cast< long >(val3);
14925 }
14926 if (obj3) {
14927 ecode4 = SWIG_AsVal_int(obj3, &val4);
14928 if (!SWIG_IsOK(ecode4)) {
14929 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14930 }
14931 arg4 = static_cast< int >(val4);
14932 }
14933 {
14934 PyThreadState* __tstate = wxPyBeginAllowThreads();
14935 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14936 wxPyEndAllowThreads(__tstate);
14937 if (PyErr_Occurred()) SWIG_fail;
14938 }
14939 {
14940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14941 }
14942 {
14943 if (created2) delete arg2;
14944 }
14945 return resultobj;
14946 fail:
14947 {
14948 if (created2) delete arg2;
14949 }
14950 return NULL;
14951 }
14952
14953
14954 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14955 PyObject *resultobj = 0;
14956 wxImage *arg1 = (wxImage *) 0 ;
14957 wxInputStream *arg2 = 0 ;
14958 wxString *arg3 = 0 ;
14959 int arg4 = (int) -1 ;
14960 bool result;
14961 void *argp1 = 0 ;
14962 int res1 = 0 ;
14963 wxPyInputStream *temp2 ;
14964 bool created2 ;
14965 bool temp3 = false ;
14966 int val4 ;
14967 int ecode4 = 0 ;
14968 PyObject * obj0 = 0 ;
14969 PyObject * obj1 = 0 ;
14970 PyObject * obj2 = 0 ;
14971 PyObject * obj3 = 0 ;
14972 char * kwnames[] = {
14973 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14974 };
14975
14976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14978 if (!SWIG_IsOK(res1)) {
14979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14980 }
14981 arg1 = reinterpret_cast< wxImage * >(argp1);
14982 {
14983 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14984 arg2 = temp2->m_wxis;
14985 created2 = false;
14986 } else {
14987 PyErr_Clear(); // clear the failure of the wxPyConvert above
14988 arg2 = wxPyCBInputStream_create(obj1, false);
14989 if (arg2 == NULL) {
14990 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14991 SWIG_fail;
14992 }
14993 created2 = true;
14994 }
14995 }
14996 {
14997 arg3 = wxString_in_helper(obj2);
14998 if (arg3 == NULL) SWIG_fail;
14999 temp3 = true;
15000 }
15001 if (obj3) {
15002 ecode4 = SWIG_AsVal_int(obj3, &val4);
15003 if (!SWIG_IsOK(ecode4)) {
15004 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15005 }
15006 arg4 = static_cast< int >(val4);
15007 }
15008 {
15009 PyThreadState* __tstate = wxPyBeginAllowThreads();
15010 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15011 wxPyEndAllowThreads(__tstate);
15012 if (PyErr_Occurred()) SWIG_fail;
15013 }
15014 {
15015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15016 }
15017 {
15018 if (created2) delete arg2;
15019 }
15020 {
15021 if (temp3)
15022 delete arg3;
15023 }
15024 return resultobj;
15025 fail:
15026 {
15027 if (created2) delete arg2;
15028 }
15029 {
15030 if (temp3)
15031 delete arg3;
15032 }
15033 return NULL;
15034 }
15035
15036
15037 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15038 PyObject *resultobj = 0;
15039 wxImage *arg1 = (wxImage *) 0 ;
15040 bool result;
15041 void *argp1 = 0 ;
15042 int res1 = 0 ;
15043 PyObject *swig_obj[1] ;
15044
15045 if (!args) SWIG_fail;
15046 swig_obj[0] = args;
15047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15048 if (!SWIG_IsOK(res1)) {
15049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15050 }
15051 arg1 = reinterpret_cast< wxImage * >(argp1);
15052 {
15053 PyThreadState* __tstate = wxPyBeginAllowThreads();
15054 result = (bool)(arg1)->Ok();
15055 wxPyEndAllowThreads(__tstate);
15056 if (PyErr_Occurred()) SWIG_fail;
15057 }
15058 {
15059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15060 }
15061 return resultobj;
15062 fail:
15063 return NULL;
15064 }
15065
15066
15067 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15068 PyObject *resultobj = 0;
15069 wxImage *arg1 = (wxImage *) 0 ;
15070 int result;
15071 void *argp1 = 0 ;
15072 int res1 = 0 ;
15073 PyObject *swig_obj[1] ;
15074
15075 if (!args) SWIG_fail;
15076 swig_obj[0] = args;
15077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15078 if (!SWIG_IsOK(res1)) {
15079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15080 }
15081 arg1 = reinterpret_cast< wxImage * >(argp1);
15082 {
15083 PyThreadState* __tstate = wxPyBeginAllowThreads();
15084 result = (int)(arg1)->GetWidth();
15085 wxPyEndAllowThreads(__tstate);
15086 if (PyErr_Occurred()) SWIG_fail;
15087 }
15088 resultobj = SWIG_From_int(static_cast< int >(result));
15089 return resultobj;
15090 fail:
15091 return NULL;
15092 }
15093
15094
15095 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15096 PyObject *resultobj = 0;
15097 wxImage *arg1 = (wxImage *) 0 ;
15098 int result;
15099 void *argp1 = 0 ;
15100 int res1 = 0 ;
15101 PyObject *swig_obj[1] ;
15102
15103 if (!args) SWIG_fail;
15104 swig_obj[0] = args;
15105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15106 if (!SWIG_IsOK(res1)) {
15107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15108 }
15109 arg1 = reinterpret_cast< wxImage * >(argp1);
15110 {
15111 PyThreadState* __tstate = wxPyBeginAllowThreads();
15112 result = (int)(arg1)->GetHeight();
15113 wxPyEndAllowThreads(__tstate);
15114 if (PyErr_Occurred()) SWIG_fail;
15115 }
15116 resultobj = SWIG_From_int(static_cast< int >(result));
15117 return resultobj;
15118 fail:
15119 return NULL;
15120 }
15121
15122
15123 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15124 PyObject *resultobj = 0;
15125 wxImage *arg1 = (wxImage *) 0 ;
15126 wxSize result;
15127 void *argp1 = 0 ;
15128 int res1 = 0 ;
15129 PyObject *swig_obj[1] ;
15130
15131 if (!args) SWIG_fail;
15132 swig_obj[0] = args;
15133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15134 if (!SWIG_IsOK(res1)) {
15135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15136 }
15137 arg1 = reinterpret_cast< wxImage * >(argp1);
15138 {
15139 PyThreadState* __tstate = wxPyBeginAllowThreads();
15140 result = wxImage_GetSize(arg1);
15141 wxPyEndAllowThreads(__tstate);
15142 if (PyErr_Occurred()) SWIG_fail;
15143 }
15144 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15145 return resultobj;
15146 fail:
15147 return NULL;
15148 }
15149
15150
15151 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15152 PyObject *resultobj = 0;
15153 wxImage *arg1 = (wxImage *) 0 ;
15154 wxRect *arg2 = 0 ;
15155 SwigValueWrapper<wxImage > result;
15156 void *argp1 = 0 ;
15157 int res1 = 0 ;
15158 wxRect temp2 ;
15159 PyObject * obj0 = 0 ;
15160 PyObject * obj1 = 0 ;
15161 char * kwnames[] = {
15162 (char *) "self",(char *) "rect", NULL
15163 };
15164
15165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15167 if (!SWIG_IsOK(res1)) {
15168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15169 }
15170 arg1 = reinterpret_cast< wxImage * >(argp1);
15171 {
15172 arg2 = &temp2;
15173 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15174 }
15175 {
15176 PyThreadState* __tstate = wxPyBeginAllowThreads();
15177 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15178 wxPyEndAllowThreads(__tstate);
15179 if (PyErr_Occurred()) SWIG_fail;
15180 }
15181 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15182 return resultobj;
15183 fail:
15184 return NULL;
15185 }
15186
15187
15188 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15189 PyObject *resultobj = 0;
15190 wxImage *arg1 = (wxImage *) 0 ;
15191 wxSize *arg2 = 0 ;
15192 wxPoint *arg3 = 0 ;
15193 int arg4 = (int) -1 ;
15194 int arg5 = (int) -1 ;
15195 int arg6 = (int) -1 ;
15196 SwigValueWrapper<wxImage > result;
15197 void *argp1 = 0 ;
15198 int res1 = 0 ;
15199 wxSize temp2 ;
15200 wxPoint temp3 ;
15201 int val4 ;
15202 int ecode4 = 0 ;
15203 int val5 ;
15204 int ecode5 = 0 ;
15205 int val6 ;
15206 int ecode6 = 0 ;
15207 PyObject * obj0 = 0 ;
15208 PyObject * obj1 = 0 ;
15209 PyObject * obj2 = 0 ;
15210 PyObject * obj3 = 0 ;
15211 PyObject * obj4 = 0 ;
15212 PyObject * obj5 = 0 ;
15213 char * kwnames[] = {
15214 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15215 };
15216
15217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15219 if (!SWIG_IsOK(res1)) {
15220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15221 }
15222 arg1 = reinterpret_cast< wxImage * >(argp1);
15223 {
15224 arg2 = &temp2;
15225 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15226 }
15227 {
15228 arg3 = &temp3;
15229 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15230 }
15231 if (obj3) {
15232 ecode4 = SWIG_AsVal_int(obj3, &val4);
15233 if (!SWIG_IsOK(ecode4)) {
15234 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15235 }
15236 arg4 = static_cast< int >(val4);
15237 }
15238 if (obj4) {
15239 ecode5 = SWIG_AsVal_int(obj4, &val5);
15240 if (!SWIG_IsOK(ecode5)) {
15241 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15242 }
15243 arg5 = static_cast< int >(val5);
15244 }
15245 if (obj5) {
15246 ecode6 = SWIG_AsVal_int(obj5, &val6);
15247 if (!SWIG_IsOK(ecode6)) {
15248 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15249 }
15250 arg6 = static_cast< int >(val6);
15251 }
15252 {
15253 PyThreadState* __tstate = wxPyBeginAllowThreads();
15254 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15255 wxPyEndAllowThreads(__tstate);
15256 if (PyErr_Occurred()) SWIG_fail;
15257 }
15258 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15259 return resultobj;
15260 fail:
15261 return NULL;
15262 }
15263
15264
15265 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15266 PyObject *resultobj = 0;
15267 wxImage *arg1 = (wxImage *) 0 ;
15268 SwigValueWrapper<wxImage > result;
15269 void *argp1 = 0 ;
15270 int res1 = 0 ;
15271 PyObject *swig_obj[1] ;
15272
15273 if (!args) SWIG_fail;
15274 swig_obj[0] = args;
15275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15276 if (!SWIG_IsOK(res1)) {
15277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15278 }
15279 arg1 = reinterpret_cast< wxImage * >(argp1);
15280 {
15281 PyThreadState* __tstate = wxPyBeginAllowThreads();
15282 result = (arg1)->Copy();
15283 wxPyEndAllowThreads(__tstate);
15284 if (PyErr_Occurred()) SWIG_fail;
15285 }
15286 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15287 return resultobj;
15288 fail:
15289 return NULL;
15290 }
15291
15292
15293 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15294 PyObject *resultobj = 0;
15295 wxImage *arg1 = (wxImage *) 0 ;
15296 wxImage *arg2 = 0 ;
15297 int arg3 ;
15298 int arg4 ;
15299 void *argp1 = 0 ;
15300 int res1 = 0 ;
15301 void *argp2 = 0 ;
15302 int res2 = 0 ;
15303 int val3 ;
15304 int ecode3 = 0 ;
15305 int val4 ;
15306 int ecode4 = 0 ;
15307 PyObject * obj0 = 0 ;
15308 PyObject * obj1 = 0 ;
15309 PyObject * obj2 = 0 ;
15310 PyObject * obj3 = 0 ;
15311 char * kwnames[] = {
15312 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15313 };
15314
15315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15317 if (!SWIG_IsOK(res1)) {
15318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15319 }
15320 arg1 = reinterpret_cast< wxImage * >(argp1);
15321 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15322 if (!SWIG_IsOK(res2)) {
15323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15324 }
15325 if (!argp2) {
15326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15327 }
15328 arg2 = reinterpret_cast< wxImage * >(argp2);
15329 ecode3 = SWIG_AsVal_int(obj2, &val3);
15330 if (!SWIG_IsOK(ecode3)) {
15331 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15332 }
15333 arg3 = static_cast< int >(val3);
15334 ecode4 = SWIG_AsVal_int(obj3, &val4);
15335 if (!SWIG_IsOK(ecode4)) {
15336 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15337 }
15338 arg4 = static_cast< int >(val4);
15339 {
15340 PyThreadState* __tstate = wxPyBeginAllowThreads();
15341 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15342 wxPyEndAllowThreads(__tstate);
15343 if (PyErr_Occurred()) SWIG_fail;
15344 }
15345 resultobj = SWIG_Py_Void();
15346 return resultobj;
15347 fail:
15348 return NULL;
15349 }
15350
15351
15352 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15353 PyObject *resultobj = 0;
15354 wxImage *arg1 = (wxImage *) 0 ;
15355 PyObject *result = 0 ;
15356 void *argp1 = 0 ;
15357 int res1 = 0 ;
15358 PyObject *swig_obj[1] ;
15359
15360 if (!args) SWIG_fail;
15361 swig_obj[0] = args;
15362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15363 if (!SWIG_IsOK(res1)) {
15364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15365 }
15366 arg1 = reinterpret_cast< wxImage * >(argp1);
15367 {
15368 PyThreadState* __tstate = wxPyBeginAllowThreads();
15369 result = (PyObject *)wxImage_GetData(arg1);
15370 wxPyEndAllowThreads(__tstate);
15371 if (PyErr_Occurred()) SWIG_fail;
15372 }
15373 resultobj = result;
15374 return resultobj;
15375 fail:
15376 return NULL;
15377 }
15378
15379
15380 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15381 PyObject *resultobj = 0;
15382 wxImage *arg1 = (wxImage *) 0 ;
15383 buffer arg2 ;
15384 int arg3 ;
15385 void *argp1 = 0 ;
15386 int res1 = 0 ;
15387 PyObject * obj0 = 0 ;
15388 PyObject * obj1 = 0 ;
15389 char * kwnames[] = {
15390 (char *) "self",(char *) "data", NULL
15391 };
15392
15393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15395 if (!SWIG_IsOK(res1)) {
15396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15397 }
15398 arg1 = reinterpret_cast< wxImage * >(argp1);
15399 {
15400 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15401 }
15402 {
15403 PyThreadState* __tstate = wxPyBeginAllowThreads();
15404 wxImage_SetData(arg1,arg2,arg3);
15405 wxPyEndAllowThreads(__tstate);
15406 if (PyErr_Occurred()) SWIG_fail;
15407 }
15408 resultobj = SWIG_Py_Void();
15409 return resultobj;
15410 fail:
15411 return NULL;
15412 }
15413
15414
15415 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15416 PyObject *resultobj = 0;
15417 wxImage *arg1 = (wxImage *) 0 ;
15418 PyObject *result = 0 ;
15419 void *argp1 = 0 ;
15420 int res1 = 0 ;
15421 PyObject *swig_obj[1] ;
15422
15423 if (!args) SWIG_fail;
15424 swig_obj[0] = args;
15425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15426 if (!SWIG_IsOK(res1)) {
15427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15428 }
15429 arg1 = reinterpret_cast< wxImage * >(argp1);
15430 {
15431 PyThreadState* __tstate = wxPyBeginAllowThreads();
15432 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15433 wxPyEndAllowThreads(__tstate);
15434 if (PyErr_Occurred()) SWIG_fail;
15435 }
15436 resultobj = result;
15437 return resultobj;
15438 fail:
15439 return NULL;
15440 }
15441
15442
15443 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15444 PyObject *resultobj = 0;
15445 wxImage *arg1 = (wxImage *) 0 ;
15446 buffer arg2 ;
15447 int arg3 ;
15448 void *argp1 = 0 ;
15449 int res1 = 0 ;
15450 PyObject * obj0 = 0 ;
15451 PyObject * obj1 = 0 ;
15452 char * kwnames[] = {
15453 (char *) "self",(char *) "data", NULL
15454 };
15455
15456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15458 if (!SWIG_IsOK(res1)) {
15459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15460 }
15461 arg1 = reinterpret_cast< wxImage * >(argp1);
15462 {
15463 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15464 }
15465 {
15466 PyThreadState* __tstate = wxPyBeginAllowThreads();
15467 wxImage_SetDataBuffer(arg1,arg2,arg3);
15468 wxPyEndAllowThreads(__tstate);
15469 if (PyErr_Occurred()) SWIG_fail;
15470 }
15471 resultobj = SWIG_Py_Void();
15472 return resultobj;
15473 fail:
15474 return NULL;
15475 }
15476
15477
15478 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15479 PyObject *resultobj = 0;
15480 wxImage *arg1 = (wxImage *) 0 ;
15481 PyObject *result = 0 ;
15482 void *argp1 = 0 ;
15483 int res1 = 0 ;
15484 PyObject *swig_obj[1] ;
15485
15486 if (!args) SWIG_fail;
15487 swig_obj[0] = args;
15488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15489 if (!SWIG_IsOK(res1)) {
15490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15491 }
15492 arg1 = reinterpret_cast< wxImage * >(argp1);
15493 {
15494 PyThreadState* __tstate = wxPyBeginAllowThreads();
15495 result = (PyObject *)wxImage_GetAlphaData(arg1);
15496 wxPyEndAllowThreads(__tstate);
15497 if (PyErr_Occurred()) SWIG_fail;
15498 }
15499 resultobj = result;
15500 return resultobj;
15501 fail:
15502 return NULL;
15503 }
15504
15505
15506 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15507 PyObject *resultobj = 0;
15508 wxImage *arg1 = (wxImage *) 0 ;
15509 buffer arg2 ;
15510 int arg3 ;
15511 void *argp1 = 0 ;
15512 int res1 = 0 ;
15513 PyObject * obj0 = 0 ;
15514 PyObject * obj1 = 0 ;
15515 char * kwnames[] = {
15516 (char *) "self",(char *) "alpha", NULL
15517 };
15518
15519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15521 if (!SWIG_IsOK(res1)) {
15522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15523 }
15524 arg1 = reinterpret_cast< wxImage * >(argp1);
15525 {
15526 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15527 }
15528 {
15529 PyThreadState* __tstate = wxPyBeginAllowThreads();
15530 wxImage_SetAlphaData(arg1,arg2,arg3);
15531 wxPyEndAllowThreads(__tstate);
15532 if (PyErr_Occurred()) SWIG_fail;
15533 }
15534 resultobj = SWIG_Py_Void();
15535 return resultobj;
15536 fail:
15537 return NULL;
15538 }
15539
15540
15541 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15542 PyObject *resultobj = 0;
15543 wxImage *arg1 = (wxImage *) 0 ;
15544 PyObject *result = 0 ;
15545 void *argp1 = 0 ;
15546 int res1 = 0 ;
15547 PyObject *swig_obj[1] ;
15548
15549 if (!args) SWIG_fail;
15550 swig_obj[0] = args;
15551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15552 if (!SWIG_IsOK(res1)) {
15553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15554 }
15555 arg1 = reinterpret_cast< wxImage * >(argp1);
15556 {
15557 PyThreadState* __tstate = wxPyBeginAllowThreads();
15558 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15559 wxPyEndAllowThreads(__tstate);
15560 if (PyErr_Occurred()) SWIG_fail;
15561 }
15562 resultobj = result;
15563 return resultobj;
15564 fail:
15565 return NULL;
15566 }
15567
15568
15569 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15570 PyObject *resultobj = 0;
15571 wxImage *arg1 = (wxImage *) 0 ;
15572 buffer arg2 ;
15573 int arg3 ;
15574 void *argp1 = 0 ;
15575 int res1 = 0 ;
15576 PyObject * obj0 = 0 ;
15577 PyObject * obj1 = 0 ;
15578 char * kwnames[] = {
15579 (char *) "self",(char *) "alpha", NULL
15580 };
15581
15582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15584 if (!SWIG_IsOK(res1)) {
15585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15586 }
15587 arg1 = reinterpret_cast< wxImage * >(argp1);
15588 {
15589 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15590 }
15591 {
15592 PyThreadState* __tstate = wxPyBeginAllowThreads();
15593 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15594 wxPyEndAllowThreads(__tstate);
15595 if (PyErr_Occurred()) SWIG_fail;
15596 }
15597 resultobj = SWIG_Py_Void();
15598 return resultobj;
15599 fail:
15600 return NULL;
15601 }
15602
15603
15604 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15605 PyObject *resultobj = 0;
15606 wxImage *arg1 = (wxImage *) 0 ;
15607 byte arg2 ;
15608 byte arg3 ;
15609 byte arg4 ;
15610 void *argp1 = 0 ;
15611 int res1 = 0 ;
15612 unsigned char val2 ;
15613 int ecode2 = 0 ;
15614 unsigned char val3 ;
15615 int ecode3 = 0 ;
15616 unsigned char val4 ;
15617 int ecode4 = 0 ;
15618 PyObject * obj0 = 0 ;
15619 PyObject * obj1 = 0 ;
15620 PyObject * obj2 = 0 ;
15621 PyObject * obj3 = 0 ;
15622 char * kwnames[] = {
15623 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15624 };
15625
15626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15628 if (!SWIG_IsOK(res1)) {
15629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15630 }
15631 arg1 = reinterpret_cast< wxImage * >(argp1);
15632 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15633 if (!SWIG_IsOK(ecode2)) {
15634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15635 }
15636 arg2 = static_cast< byte >(val2);
15637 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15638 if (!SWIG_IsOK(ecode3)) {
15639 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15640 }
15641 arg3 = static_cast< byte >(val3);
15642 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15643 if (!SWIG_IsOK(ecode4)) {
15644 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15645 }
15646 arg4 = static_cast< byte >(val4);
15647 {
15648 PyThreadState* __tstate = wxPyBeginAllowThreads();
15649 (arg1)->SetMaskColour(arg2,arg3,arg4);
15650 wxPyEndAllowThreads(__tstate);
15651 if (PyErr_Occurred()) SWIG_fail;
15652 }
15653 resultobj = SWIG_Py_Void();
15654 return resultobj;
15655 fail:
15656 return NULL;
15657 }
15658
15659
15660 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15661 PyObject *resultobj = 0;
15662 wxImage *arg1 = (wxImage *) 0 ;
15663 byte *arg2 = (byte *) 0 ;
15664 byte *arg3 = (byte *) 0 ;
15665 byte *arg4 = (byte *) 0 ;
15666 void *argp1 = 0 ;
15667 int res1 = 0 ;
15668 byte temp2 ;
15669 int res2 = SWIG_TMPOBJ ;
15670 byte temp3 ;
15671 int res3 = SWIG_TMPOBJ ;
15672 byte temp4 ;
15673 int res4 = SWIG_TMPOBJ ;
15674 PyObject *swig_obj[1] ;
15675
15676 arg2 = &temp2;
15677 arg3 = &temp3;
15678 arg4 = &temp4;
15679 if (!args) SWIG_fail;
15680 swig_obj[0] = args;
15681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15682 if (!SWIG_IsOK(res1)) {
15683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15684 }
15685 arg1 = reinterpret_cast< wxImage * >(argp1);
15686 {
15687 PyThreadState* __tstate = wxPyBeginAllowThreads();
15688 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15689 wxPyEndAllowThreads(__tstate);
15690 if (PyErr_Occurred()) SWIG_fail;
15691 }
15692 resultobj = SWIG_Py_Void();
15693 if (SWIG_IsTmpObj(res2)) {
15694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15695 } else {
15696 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15698 }
15699 if (SWIG_IsTmpObj(res3)) {
15700 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15701 } else {
15702 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15704 }
15705 if (SWIG_IsTmpObj(res4)) {
15706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15707 } else {
15708 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15710 }
15711 return resultobj;
15712 fail:
15713 return NULL;
15714 }
15715
15716
15717 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15718 PyObject *resultobj = 0;
15719 wxImage *arg1 = (wxImage *) 0 ;
15720 byte result;
15721 void *argp1 = 0 ;
15722 int res1 = 0 ;
15723 PyObject *swig_obj[1] ;
15724
15725 if (!args) SWIG_fail;
15726 swig_obj[0] = args;
15727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15728 if (!SWIG_IsOK(res1)) {
15729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15730 }
15731 arg1 = reinterpret_cast< wxImage * >(argp1);
15732 {
15733 PyThreadState* __tstate = wxPyBeginAllowThreads();
15734 result = (byte)(arg1)->GetMaskRed();
15735 wxPyEndAllowThreads(__tstate);
15736 if (PyErr_Occurred()) SWIG_fail;
15737 }
15738 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15739 return resultobj;
15740 fail:
15741 return NULL;
15742 }
15743
15744
15745 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15746 PyObject *resultobj = 0;
15747 wxImage *arg1 = (wxImage *) 0 ;
15748 byte result;
15749 void *argp1 = 0 ;
15750 int res1 = 0 ;
15751 PyObject *swig_obj[1] ;
15752
15753 if (!args) SWIG_fail;
15754 swig_obj[0] = args;
15755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15756 if (!SWIG_IsOK(res1)) {
15757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15758 }
15759 arg1 = reinterpret_cast< wxImage * >(argp1);
15760 {
15761 PyThreadState* __tstate = wxPyBeginAllowThreads();
15762 result = (byte)(arg1)->GetMaskGreen();
15763 wxPyEndAllowThreads(__tstate);
15764 if (PyErr_Occurred()) SWIG_fail;
15765 }
15766 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15767 return resultobj;
15768 fail:
15769 return NULL;
15770 }
15771
15772
15773 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15774 PyObject *resultobj = 0;
15775 wxImage *arg1 = (wxImage *) 0 ;
15776 byte result;
15777 void *argp1 = 0 ;
15778 int res1 = 0 ;
15779 PyObject *swig_obj[1] ;
15780
15781 if (!args) SWIG_fail;
15782 swig_obj[0] = args;
15783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15784 if (!SWIG_IsOK(res1)) {
15785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15786 }
15787 arg1 = reinterpret_cast< wxImage * >(argp1);
15788 {
15789 PyThreadState* __tstate = wxPyBeginAllowThreads();
15790 result = (byte)(arg1)->GetMaskBlue();
15791 wxPyEndAllowThreads(__tstate);
15792 if (PyErr_Occurred()) SWIG_fail;
15793 }
15794 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15795 return resultobj;
15796 fail:
15797 return NULL;
15798 }
15799
15800
15801 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15802 PyObject *resultobj = 0;
15803 wxImage *arg1 = (wxImage *) 0 ;
15804 bool arg2 = (bool) true ;
15805 void *argp1 = 0 ;
15806 int res1 = 0 ;
15807 bool val2 ;
15808 int ecode2 = 0 ;
15809 PyObject * obj0 = 0 ;
15810 PyObject * obj1 = 0 ;
15811 char * kwnames[] = {
15812 (char *) "self",(char *) "mask", NULL
15813 };
15814
15815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15817 if (!SWIG_IsOK(res1)) {
15818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15819 }
15820 arg1 = reinterpret_cast< wxImage * >(argp1);
15821 if (obj1) {
15822 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15823 if (!SWIG_IsOK(ecode2)) {
15824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15825 }
15826 arg2 = static_cast< bool >(val2);
15827 }
15828 {
15829 PyThreadState* __tstate = wxPyBeginAllowThreads();
15830 (arg1)->SetMask(arg2);
15831 wxPyEndAllowThreads(__tstate);
15832 if (PyErr_Occurred()) SWIG_fail;
15833 }
15834 resultobj = SWIG_Py_Void();
15835 return resultobj;
15836 fail:
15837 return NULL;
15838 }
15839
15840
15841 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15842 PyObject *resultobj = 0;
15843 wxImage *arg1 = (wxImage *) 0 ;
15844 bool result;
15845 void *argp1 = 0 ;
15846 int res1 = 0 ;
15847 PyObject *swig_obj[1] ;
15848
15849 if (!args) SWIG_fail;
15850 swig_obj[0] = args;
15851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15852 if (!SWIG_IsOK(res1)) {
15853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15854 }
15855 arg1 = reinterpret_cast< wxImage * >(argp1);
15856 {
15857 PyThreadState* __tstate = wxPyBeginAllowThreads();
15858 result = (bool)(arg1)->HasMask();
15859 wxPyEndAllowThreads(__tstate);
15860 if (PyErr_Occurred()) SWIG_fail;
15861 }
15862 {
15863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15864 }
15865 return resultobj;
15866 fail:
15867 return NULL;
15868 }
15869
15870
15871 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15872 PyObject *resultobj = 0;
15873 wxImage *arg1 = (wxImage *) 0 ;
15874 double arg2 ;
15875 wxPoint *arg3 = 0 ;
15876 bool arg4 = (bool) true ;
15877 wxPoint *arg5 = (wxPoint *) NULL ;
15878 SwigValueWrapper<wxImage > result;
15879 void *argp1 = 0 ;
15880 int res1 = 0 ;
15881 double val2 ;
15882 int ecode2 = 0 ;
15883 wxPoint temp3 ;
15884 bool val4 ;
15885 int ecode4 = 0 ;
15886 void *argp5 = 0 ;
15887 int res5 = 0 ;
15888 PyObject * obj0 = 0 ;
15889 PyObject * obj1 = 0 ;
15890 PyObject * obj2 = 0 ;
15891 PyObject * obj3 = 0 ;
15892 PyObject * obj4 = 0 ;
15893 char * kwnames[] = {
15894 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15895 };
15896
15897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15899 if (!SWIG_IsOK(res1)) {
15900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15901 }
15902 arg1 = reinterpret_cast< wxImage * >(argp1);
15903 ecode2 = SWIG_AsVal_double(obj1, &val2);
15904 if (!SWIG_IsOK(ecode2)) {
15905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15906 }
15907 arg2 = static_cast< double >(val2);
15908 {
15909 arg3 = &temp3;
15910 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15911 }
15912 if (obj3) {
15913 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15914 if (!SWIG_IsOK(ecode4)) {
15915 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15916 }
15917 arg4 = static_cast< bool >(val4);
15918 }
15919 if (obj4) {
15920 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15921 if (!SWIG_IsOK(res5)) {
15922 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15923 }
15924 arg5 = reinterpret_cast< wxPoint * >(argp5);
15925 }
15926 {
15927 PyThreadState* __tstate = wxPyBeginAllowThreads();
15928 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15929 wxPyEndAllowThreads(__tstate);
15930 if (PyErr_Occurred()) SWIG_fail;
15931 }
15932 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15933 return resultobj;
15934 fail:
15935 return NULL;
15936 }
15937
15938
15939 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15940 PyObject *resultobj = 0;
15941 wxImage *arg1 = (wxImage *) 0 ;
15942 bool arg2 = (bool) true ;
15943 SwigValueWrapper<wxImage > result;
15944 void *argp1 = 0 ;
15945 int res1 = 0 ;
15946 bool val2 ;
15947 int ecode2 = 0 ;
15948 PyObject * obj0 = 0 ;
15949 PyObject * obj1 = 0 ;
15950 char * kwnames[] = {
15951 (char *) "self",(char *) "clockwise", NULL
15952 };
15953
15954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15956 if (!SWIG_IsOK(res1)) {
15957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15958 }
15959 arg1 = reinterpret_cast< wxImage * >(argp1);
15960 if (obj1) {
15961 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15962 if (!SWIG_IsOK(ecode2)) {
15963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15964 }
15965 arg2 = static_cast< bool >(val2);
15966 }
15967 {
15968 PyThreadState* __tstate = wxPyBeginAllowThreads();
15969 result = (arg1)->Rotate90(arg2);
15970 wxPyEndAllowThreads(__tstate);
15971 if (PyErr_Occurred()) SWIG_fail;
15972 }
15973 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15974 return resultobj;
15975 fail:
15976 return NULL;
15977 }
15978
15979
15980 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15981 PyObject *resultobj = 0;
15982 wxImage *arg1 = (wxImage *) 0 ;
15983 bool arg2 = (bool) true ;
15984 SwigValueWrapper<wxImage > result;
15985 void *argp1 = 0 ;
15986 int res1 = 0 ;
15987 bool val2 ;
15988 int ecode2 = 0 ;
15989 PyObject * obj0 = 0 ;
15990 PyObject * obj1 = 0 ;
15991 char * kwnames[] = {
15992 (char *) "self",(char *) "horizontally", NULL
15993 };
15994
15995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15997 if (!SWIG_IsOK(res1)) {
15998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15999 }
16000 arg1 = reinterpret_cast< wxImage * >(argp1);
16001 if (obj1) {
16002 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16003 if (!SWIG_IsOK(ecode2)) {
16004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16005 }
16006 arg2 = static_cast< bool >(val2);
16007 }
16008 {
16009 PyThreadState* __tstate = wxPyBeginAllowThreads();
16010 result = (arg1)->Mirror(arg2);
16011 wxPyEndAllowThreads(__tstate);
16012 if (PyErr_Occurred()) SWIG_fail;
16013 }
16014 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16015 return resultobj;
16016 fail:
16017 return NULL;
16018 }
16019
16020
16021 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16022 PyObject *resultobj = 0;
16023 wxImage *arg1 = (wxImage *) 0 ;
16024 byte arg2 ;
16025 byte arg3 ;
16026 byte arg4 ;
16027 byte arg5 ;
16028 byte arg6 ;
16029 byte arg7 ;
16030 void *argp1 = 0 ;
16031 int res1 = 0 ;
16032 unsigned char val2 ;
16033 int ecode2 = 0 ;
16034 unsigned char val3 ;
16035 int ecode3 = 0 ;
16036 unsigned char val4 ;
16037 int ecode4 = 0 ;
16038 unsigned char val5 ;
16039 int ecode5 = 0 ;
16040 unsigned char val6 ;
16041 int ecode6 = 0 ;
16042 unsigned char val7 ;
16043 int ecode7 = 0 ;
16044 PyObject * obj0 = 0 ;
16045 PyObject * obj1 = 0 ;
16046 PyObject * obj2 = 0 ;
16047 PyObject * obj3 = 0 ;
16048 PyObject * obj4 = 0 ;
16049 PyObject * obj5 = 0 ;
16050 PyObject * obj6 = 0 ;
16051 char * kwnames[] = {
16052 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16053 };
16054
16055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16057 if (!SWIG_IsOK(res1)) {
16058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16059 }
16060 arg1 = reinterpret_cast< wxImage * >(argp1);
16061 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16062 if (!SWIG_IsOK(ecode2)) {
16063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16064 }
16065 arg2 = static_cast< byte >(val2);
16066 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16067 if (!SWIG_IsOK(ecode3)) {
16068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16069 }
16070 arg3 = static_cast< byte >(val3);
16071 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16072 if (!SWIG_IsOK(ecode4)) {
16073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16074 }
16075 arg4 = static_cast< byte >(val4);
16076 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16077 if (!SWIG_IsOK(ecode5)) {
16078 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16079 }
16080 arg5 = static_cast< byte >(val5);
16081 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16082 if (!SWIG_IsOK(ecode6)) {
16083 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16084 }
16085 arg6 = static_cast< byte >(val6);
16086 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16087 if (!SWIG_IsOK(ecode7)) {
16088 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16089 }
16090 arg7 = static_cast< byte >(val7);
16091 {
16092 PyThreadState* __tstate = wxPyBeginAllowThreads();
16093 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16094 wxPyEndAllowThreads(__tstate);
16095 if (PyErr_Occurred()) SWIG_fail;
16096 }
16097 resultobj = SWIG_Py_Void();
16098 return resultobj;
16099 fail:
16100 return NULL;
16101 }
16102
16103
16104 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16105 PyObject *resultobj = 0;
16106 wxImage *arg1 = (wxImage *) 0 ;
16107 double arg2 = (double) 0.299 ;
16108 double arg3 = (double) 0.587 ;
16109 double arg4 = (double) 0.114 ;
16110 SwigValueWrapper<wxImage > result;
16111 void *argp1 = 0 ;
16112 int res1 = 0 ;
16113 double val2 ;
16114 int ecode2 = 0 ;
16115 double val3 ;
16116 int ecode3 = 0 ;
16117 double val4 ;
16118 int ecode4 = 0 ;
16119 PyObject * obj0 = 0 ;
16120 PyObject * obj1 = 0 ;
16121 PyObject * obj2 = 0 ;
16122 PyObject * obj3 = 0 ;
16123 char * kwnames[] = {
16124 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16125 };
16126
16127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16129 if (!SWIG_IsOK(res1)) {
16130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16131 }
16132 arg1 = reinterpret_cast< wxImage * >(argp1);
16133 if (obj1) {
16134 ecode2 = SWIG_AsVal_double(obj1, &val2);
16135 if (!SWIG_IsOK(ecode2)) {
16136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16137 }
16138 arg2 = static_cast< double >(val2);
16139 }
16140 if (obj2) {
16141 ecode3 = SWIG_AsVal_double(obj2, &val3);
16142 if (!SWIG_IsOK(ecode3)) {
16143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16144 }
16145 arg3 = static_cast< double >(val3);
16146 }
16147 if (obj3) {
16148 ecode4 = SWIG_AsVal_double(obj3, &val4);
16149 if (!SWIG_IsOK(ecode4)) {
16150 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16151 }
16152 arg4 = static_cast< double >(val4);
16153 }
16154 {
16155 PyThreadState* __tstate = wxPyBeginAllowThreads();
16156 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16157 wxPyEndAllowThreads(__tstate);
16158 if (PyErr_Occurred()) SWIG_fail;
16159 }
16160 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16161 return resultobj;
16162 fail:
16163 return NULL;
16164 }
16165
16166
16167 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16168 PyObject *resultobj = 0;
16169 wxImage *arg1 = (wxImage *) 0 ;
16170 byte arg2 ;
16171 byte arg3 ;
16172 byte arg4 ;
16173 SwigValueWrapper<wxImage > result;
16174 void *argp1 = 0 ;
16175 int res1 = 0 ;
16176 unsigned char val2 ;
16177 int ecode2 = 0 ;
16178 unsigned char val3 ;
16179 int ecode3 = 0 ;
16180 unsigned char val4 ;
16181 int ecode4 = 0 ;
16182 PyObject * obj0 = 0 ;
16183 PyObject * obj1 = 0 ;
16184 PyObject * obj2 = 0 ;
16185 PyObject * obj3 = 0 ;
16186 char * kwnames[] = {
16187 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16188 };
16189
16190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16192 if (!SWIG_IsOK(res1)) {
16193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16194 }
16195 arg1 = reinterpret_cast< wxImage * >(argp1);
16196 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16197 if (!SWIG_IsOK(ecode2)) {
16198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16199 }
16200 arg2 = static_cast< byte >(val2);
16201 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16202 if (!SWIG_IsOK(ecode3)) {
16203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16204 }
16205 arg3 = static_cast< byte >(val3);
16206 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16207 if (!SWIG_IsOK(ecode4)) {
16208 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16209 }
16210 arg4 = static_cast< byte >(val4);
16211 {
16212 PyThreadState* __tstate = wxPyBeginAllowThreads();
16213 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16214 wxPyEndAllowThreads(__tstate);
16215 if (PyErr_Occurred()) SWIG_fail;
16216 }
16217 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16218 return resultobj;
16219 fail:
16220 return NULL;
16221 }
16222
16223
16224 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16225 PyObject *resultobj = 0;
16226 wxImage *arg1 = (wxImage *) 0 ;
16227 wxString *arg2 = 0 ;
16228 wxString *arg3 = 0 ;
16229 void *argp1 = 0 ;
16230 int res1 = 0 ;
16231 bool temp2 = false ;
16232 bool temp3 = false ;
16233 PyObject * obj0 = 0 ;
16234 PyObject * obj1 = 0 ;
16235 PyObject * obj2 = 0 ;
16236 char * kwnames[] = {
16237 (char *) "self",(char *) "name",(char *) "value", NULL
16238 };
16239
16240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16242 if (!SWIG_IsOK(res1)) {
16243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16244 }
16245 arg1 = reinterpret_cast< wxImage * >(argp1);
16246 {
16247 arg2 = wxString_in_helper(obj1);
16248 if (arg2 == NULL) SWIG_fail;
16249 temp2 = true;
16250 }
16251 {
16252 arg3 = wxString_in_helper(obj2);
16253 if (arg3 == NULL) SWIG_fail;
16254 temp3 = true;
16255 }
16256 {
16257 PyThreadState* __tstate = wxPyBeginAllowThreads();
16258 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16259 wxPyEndAllowThreads(__tstate);
16260 if (PyErr_Occurred()) SWIG_fail;
16261 }
16262 resultobj = SWIG_Py_Void();
16263 {
16264 if (temp2)
16265 delete arg2;
16266 }
16267 {
16268 if (temp3)
16269 delete arg3;
16270 }
16271 return resultobj;
16272 fail:
16273 {
16274 if (temp2)
16275 delete arg2;
16276 }
16277 {
16278 if (temp3)
16279 delete arg3;
16280 }
16281 return NULL;
16282 }
16283
16284
16285 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16286 PyObject *resultobj = 0;
16287 wxImage *arg1 = (wxImage *) 0 ;
16288 wxString *arg2 = 0 ;
16289 int arg3 ;
16290 void *argp1 = 0 ;
16291 int res1 = 0 ;
16292 bool temp2 = false ;
16293 int val3 ;
16294 int ecode3 = 0 ;
16295 PyObject * obj0 = 0 ;
16296 PyObject * obj1 = 0 ;
16297 PyObject * obj2 = 0 ;
16298 char * kwnames[] = {
16299 (char *) "self",(char *) "name",(char *) "value", NULL
16300 };
16301
16302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16304 if (!SWIG_IsOK(res1)) {
16305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16306 }
16307 arg1 = reinterpret_cast< wxImage * >(argp1);
16308 {
16309 arg2 = wxString_in_helper(obj1);
16310 if (arg2 == NULL) SWIG_fail;
16311 temp2 = true;
16312 }
16313 ecode3 = SWIG_AsVal_int(obj2, &val3);
16314 if (!SWIG_IsOK(ecode3)) {
16315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16316 }
16317 arg3 = static_cast< int >(val3);
16318 {
16319 PyThreadState* __tstate = wxPyBeginAllowThreads();
16320 (arg1)->SetOption((wxString const &)*arg2,arg3);
16321 wxPyEndAllowThreads(__tstate);
16322 if (PyErr_Occurred()) SWIG_fail;
16323 }
16324 resultobj = SWIG_Py_Void();
16325 {
16326 if (temp2)
16327 delete arg2;
16328 }
16329 return resultobj;
16330 fail:
16331 {
16332 if (temp2)
16333 delete arg2;
16334 }
16335 return NULL;
16336 }
16337
16338
16339 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16340 PyObject *resultobj = 0;
16341 wxImage *arg1 = (wxImage *) 0 ;
16342 wxString *arg2 = 0 ;
16343 wxString result;
16344 void *argp1 = 0 ;
16345 int res1 = 0 ;
16346 bool temp2 = false ;
16347 PyObject * obj0 = 0 ;
16348 PyObject * obj1 = 0 ;
16349 char * kwnames[] = {
16350 (char *) "self",(char *) "name", NULL
16351 };
16352
16353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16355 if (!SWIG_IsOK(res1)) {
16356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16357 }
16358 arg1 = reinterpret_cast< wxImage * >(argp1);
16359 {
16360 arg2 = wxString_in_helper(obj1);
16361 if (arg2 == NULL) SWIG_fail;
16362 temp2 = true;
16363 }
16364 {
16365 PyThreadState* __tstate = wxPyBeginAllowThreads();
16366 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16367 wxPyEndAllowThreads(__tstate);
16368 if (PyErr_Occurred()) SWIG_fail;
16369 }
16370 {
16371 #if wxUSE_UNICODE
16372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16373 #else
16374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16375 #endif
16376 }
16377 {
16378 if (temp2)
16379 delete arg2;
16380 }
16381 return resultobj;
16382 fail:
16383 {
16384 if (temp2)
16385 delete arg2;
16386 }
16387 return NULL;
16388 }
16389
16390
16391 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16392 PyObject *resultobj = 0;
16393 wxImage *arg1 = (wxImage *) 0 ;
16394 wxString *arg2 = 0 ;
16395 int result;
16396 void *argp1 = 0 ;
16397 int res1 = 0 ;
16398 bool temp2 = false ;
16399 PyObject * obj0 = 0 ;
16400 PyObject * obj1 = 0 ;
16401 char * kwnames[] = {
16402 (char *) "self",(char *) "name", NULL
16403 };
16404
16405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16407 if (!SWIG_IsOK(res1)) {
16408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16409 }
16410 arg1 = reinterpret_cast< wxImage * >(argp1);
16411 {
16412 arg2 = wxString_in_helper(obj1);
16413 if (arg2 == NULL) SWIG_fail;
16414 temp2 = true;
16415 }
16416 {
16417 PyThreadState* __tstate = wxPyBeginAllowThreads();
16418 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16419 wxPyEndAllowThreads(__tstate);
16420 if (PyErr_Occurred()) SWIG_fail;
16421 }
16422 resultobj = SWIG_From_int(static_cast< int >(result));
16423 {
16424 if (temp2)
16425 delete arg2;
16426 }
16427 return resultobj;
16428 fail:
16429 {
16430 if (temp2)
16431 delete arg2;
16432 }
16433 return NULL;
16434 }
16435
16436
16437 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16438 PyObject *resultobj = 0;
16439 wxImage *arg1 = (wxImage *) 0 ;
16440 wxString *arg2 = 0 ;
16441 bool result;
16442 void *argp1 = 0 ;
16443 int res1 = 0 ;
16444 bool temp2 = false ;
16445 PyObject * obj0 = 0 ;
16446 PyObject * obj1 = 0 ;
16447 char * kwnames[] = {
16448 (char *) "self",(char *) "name", NULL
16449 };
16450
16451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16453 if (!SWIG_IsOK(res1)) {
16454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16455 }
16456 arg1 = reinterpret_cast< wxImage * >(argp1);
16457 {
16458 arg2 = wxString_in_helper(obj1);
16459 if (arg2 == NULL) SWIG_fail;
16460 temp2 = true;
16461 }
16462 {
16463 PyThreadState* __tstate = wxPyBeginAllowThreads();
16464 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16465 wxPyEndAllowThreads(__tstate);
16466 if (PyErr_Occurred()) SWIG_fail;
16467 }
16468 {
16469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16470 }
16471 {
16472 if (temp2)
16473 delete arg2;
16474 }
16475 return resultobj;
16476 fail:
16477 {
16478 if (temp2)
16479 delete arg2;
16480 }
16481 return NULL;
16482 }
16483
16484
16485 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16486 PyObject *resultobj = 0;
16487 wxImage *arg1 = (wxImage *) 0 ;
16488 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16489 unsigned long result;
16490 void *argp1 = 0 ;
16491 int res1 = 0 ;
16492 unsigned long val2 ;
16493 int ecode2 = 0 ;
16494 PyObject * obj0 = 0 ;
16495 PyObject * obj1 = 0 ;
16496 char * kwnames[] = {
16497 (char *) "self",(char *) "stopafter", NULL
16498 };
16499
16500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16502 if (!SWIG_IsOK(res1)) {
16503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16504 }
16505 arg1 = reinterpret_cast< wxImage * >(argp1);
16506 if (obj1) {
16507 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16508 if (!SWIG_IsOK(ecode2)) {
16509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16510 }
16511 arg2 = static_cast< unsigned long >(val2);
16512 }
16513 {
16514 PyThreadState* __tstate = wxPyBeginAllowThreads();
16515 result = (unsigned long)(arg1)->CountColours(arg2);
16516 wxPyEndAllowThreads(__tstate);
16517 if (PyErr_Occurred()) SWIG_fail;
16518 }
16519 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16520 return resultobj;
16521 fail:
16522 return NULL;
16523 }
16524
16525
16526 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16527 PyObject *resultobj = 0;
16528 wxImage *arg1 = (wxImage *) 0 ;
16529 wxImageHistogram *arg2 = 0 ;
16530 unsigned long result;
16531 void *argp1 = 0 ;
16532 int res1 = 0 ;
16533 void *argp2 = 0 ;
16534 int res2 = 0 ;
16535 PyObject * obj0 = 0 ;
16536 PyObject * obj1 = 0 ;
16537 char * kwnames[] = {
16538 (char *) "self",(char *) "h", NULL
16539 };
16540
16541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16543 if (!SWIG_IsOK(res1)) {
16544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16545 }
16546 arg1 = reinterpret_cast< wxImage * >(argp1);
16547 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16548 if (!SWIG_IsOK(res2)) {
16549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16550 }
16551 if (!argp2) {
16552 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16553 }
16554 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16555 {
16556 PyThreadState* __tstate = wxPyBeginAllowThreads();
16557 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16558 wxPyEndAllowThreads(__tstate);
16559 if (PyErr_Occurred()) SWIG_fail;
16560 }
16561 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16562 return resultobj;
16563 fail:
16564 return NULL;
16565 }
16566
16567
16568 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16569 PyObject *resultobj = 0;
16570 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16571 void *argp1 = 0 ;
16572 int res1 = 0 ;
16573 PyObject * obj0 = 0 ;
16574 char * kwnames[] = {
16575 (char *) "handler", NULL
16576 };
16577
16578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16580 if (!SWIG_IsOK(res1)) {
16581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16582 }
16583 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16584 {
16585 PyThreadState* __tstate = wxPyBeginAllowThreads();
16586 wxImage::AddHandler(arg1);
16587 wxPyEndAllowThreads(__tstate);
16588 if (PyErr_Occurred()) SWIG_fail;
16589 }
16590 resultobj = SWIG_Py_Void();
16591 return resultobj;
16592 fail:
16593 return NULL;
16594 }
16595
16596
16597 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16598 PyObject *resultobj = 0;
16599 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16600 void *argp1 = 0 ;
16601 int res1 = 0 ;
16602 PyObject * obj0 = 0 ;
16603 char * kwnames[] = {
16604 (char *) "handler", NULL
16605 };
16606
16607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16609 if (!SWIG_IsOK(res1)) {
16610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16611 }
16612 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16613 {
16614 PyThreadState* __tstate = wxPyBeginAllowThreads();
16615 wxImage::InsertHandler(arg1);
16616 wxPyEndAllowThreads(__tstate);
16617 if (PyErr_Occurred()) SWIG_fail;
16618 }
16619 resultobj = SWIG_Py_Void();
16620 return resultobj;
16621 fail:
16622 return NULL;
16623 }
16624
16625
16626 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16627 PyObject *resultobj = 0;
16628 wxString *arg1 = 0 ;
16629 bool result;
16630 bool temp1 = false ;
16631 PyObject * obj0 = 0 ;
16632 char * kwnames[] = {
16633 (char *) "name", NULL
16634 };
16635
16636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16637 {
16638 arg1 = wxString_in_helper(obj0);
16639 if (arg1 == NULL) SWIG_fail;
16640 temp1 = true;
16641 }
16642 {
16643 PyThreadState* __tstate = wxPyBeginAllowThreads();
16644 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16645 wxPyEndAllowThreads(__tstate);
16646 if (PyErr_Occurred()) SWIG_fail;
16647 }
16648 {
16649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16650 }
16651 {
16652 if (temp1)
16653 delete arg1;
16654 }
16655 return resultobj;
16656 fail:
16657 {
16658 if (temp1)
16659 delete arg1;
16660 }
16661 return NULL;
16662 }
16663
16664
16665 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16666 PyObject *resultobj = 0;
16667 PyObject *result = 0 ;
16668
16669 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16670 {
16671 PyThreadState* __tstate = wxPyBeginAllowThreads();
16672 result = (PyObject *)wxImage_GetHandlers();
16673 wxPyEndAllowThreads(__tstate);
16674 if (PyErr_Occurred()) SWIG_fail;
16675 }
16676 resultobj = result;
16677 return resultobj;
16678 fail:
16679 return NULL;
16680 }
16681
16682
16683 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16684 PyObject *resultobj = 0;
16685 wxString result;
16686
16687 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16688 {
16689 PyThreadState* __tstate = wxPyBeginAllowThreads();
16690 result = wxImage::GetImageExtWildcard();
16691 wxPyEndAllowThreads(__tstate);
16692 if (PyErr_Occurred()) SWIG_fail;
16693 }
16694 {
16695 #if wxUSE_UNICODE
16696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16697 #else
16698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16699 #endif
16700 }
16701 return resultobj;
16702 fail:
16703 return NULL;
16704 }
16705
16706
16707 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16708 PyObject *resultobj = 0;
16709 wxImage *arg1 = (wxImage *) 0 ;
16710 int arg2 = (int) -1 ;
16711 wxBitmap result;
16712 void *argp1 = 0 ;
16713 int res1 = 0 ;
16714 int val2 ;
16715 int ecode2 = 0 ;
16716 PyObject * obj0 = 0 ;
16717 PyObject * obj1 = 0 ;
16718 char * kwnames[] = {
16719 (char *) "self",(char *) "depth", NULL
16720 };
16721
16722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16724 if (!SWIG_IsOK(res1)) {
16725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16726 }
16727 arg1 = reinterpret_cast< wxImage * >(argp1);
16728 if (obj1) {
16729 ecode2 = SWIG_AsVal_int(obj1, &val2);
16730 if (!SWIG_IsOK(ecode2)) {
16731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16732 }
16733 arg2 = static_cast< int >(val2);
16734 }
16735 {
16736 if (!wxPyCheckForApp()) SWIG_fail;
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 result = wxImage_ConvertToBitmap(arg1,arg2);
16739 wxPyEndAllowThreads(__tstate);
16740 if (PyErr_Occurred()) SWIG_fail;
16741 }
16742 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16743 return resultobj;
16744 fail:
16745 return NULL;
16746 }
16747
16748
16749 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16750 PyObject *resultobj = 0;
16751 wxImage *arg1 = (wxImage *) 0 ;
16752 byte arg2 ;
16753 byte arg3 ;
16754 byte arg4 ;
16755 wxBitmap result;
16756 void *argp1 = 0 ;
16757 int res1 = 0 ;
16758 unsigned char val2 ;
16759 int ecode2 = 0 ;
16760 unsigned char val3 ;
16761 int ecode3 = 0 ;
16762 unsigned char val4 ;
16763 int ecode4 = 0 ;
16764 PyObject * obj0 = 0 ;
16765 PyObject * obj1 = 0 ;
16766 PyObject * obj2 = 0 ;
16767 PyObject * obj3 = 0 ;
16768 char * kwnames[] = {
16769 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16770 };
16771
16772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16774 if (!SWIG_IsOK(res1)) {
16775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16776 }
16777 arg1 = reinterpret_cast< wxImage * >(argp1);
16778 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16779 if (!SWIG_IsOK(ecode2)) {
16780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16781 }
16782 arg2 = static_cast< byte >(val2);
16783 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16784 if (!SWIG_IsOK(ecode3)) {
16785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16786 }
16787 arg3 = static_cast< byte >(val3);
16788 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16789 if (!SWIG_IsOK(ecode4)) {
16790 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16791 }
16792 arg4 = static_cast< byte >(val4);
16793 {
16794 if (!wxPyCheckForApp()) SWIG_fail;
16795 PyThreadState* __tstate = wxPyBeginAllowThreads();
16796 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16797 wxPyEndAllowThreads(__tstate);
16798 if (PyErr_Occurred()) SWIG_fail;
16799 }
16800 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16801 return resultobj;
16802 fail:
16803 return NULL;
16804 }
16805
16806
16807 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16808 PyObject *resultobj = 0;
16809 wxImage *arg1 = (wxImage *) 0 ;
16810 double arg2 ;
16811 void *argp1 = 0 ;
16812 int res1 = 0 ;
16813 double val2 ;
16814 int ecode2 = 0 ;
16815 PyObject * obj0 = 0 ;
16816 PyObject * obj1 = 0 ;
16817 char * kwnames[] = {
16818 (char *) "self",(char *) "angle", NULL
16819 };
16820
16821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16823 if (!SWIG_IsOK(res1)) {
16824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16825 }
16826 arg1 = reinterpret_cast< wxImage * >(argp1);
16827 ecode2 = SWIG_AsVal_double(obj1, &val2);
16828 if (!SWIG_IsOK(ecode2)) {
16829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16830 }
16831 arg2 = static_cast< double >(val2);
16832 {
16833 PyThreadState* __tstate = wxPyBeginAllowThreads();
16834 (arg1)->RotateHue(arg2);
16835 wxPyEndAllowThreads(__tstate);
16836 if (PyErr_Occurred()) SWIG_fail;
16837 }
16838 resultobj = SWIG_Py_Void();
16839 return resultobj;
16840 fail:
16841 return NULL;
16842 }
16843
16844
16845 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16846 PyObject *resultobj = 0;
16847 wxImage_RGBValue arg1 ;
16848 wxImage_HSVValue result;
16849 void *argp1 ;
16850 int res1 = 0 ;
16851 PyObject * obj0 = 0 ;
16852 char * kwnames[] = {
16853 (char *) "rgb", NULL
16854 };
16855
16856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16857 {
16858 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16859 if (!SWIG_IsOK(res1)) {
16860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16861 }
16862 if (!argp1) {
16863 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16864 } else {
16865 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16866 arg1 = *temp;
16867 if (SWIG_IsNewObj(res1)) delete temp;
16868 }
16869 }
16870 {
16871 PyThreadState* __tstate = wxPyBeginAllowThreads();
16872 result = wxImage::RGBtoHSV(arg1);
16873 wxPyEndAllowThreads(__tstate);
16874 if (PyErr_Occurred()) SWIG_fail;
16875 }
16876 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16877 return resultobj;
16878 fail:
16879 return NULL;
16880 }
16881
16882
16883 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16884 PyObject *resultobj = 0;
16885 wxImage_HSVValue arg1 ;
16886 wxImage_RGBValue result;
16887 void *argp1 ;
16888 int res1 = 0 ;
16889 PyObject * obj0 = 0 ;
16890 char * kwnames[] = {
16891 (char *) "hsv", NULL
16892 };
16893
16894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16895 {
16896 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16897 if (!SWIG_IsOK(res1)) {
16898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16899 }
16900 if (!argp1) {
16901 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16902 } else {
16903 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16904 arg1 = *temp;
16905 if (SWIG_IsNewObj(res1)) delete temp;
16906 }
16907 }
16908 {
16909 PyThreadState* __tstate = wxPyBeginAllowThreads();
16910 result = wxImage::HSVtoRGB(arg1);
16911 wxPyEndAllowThreads(__tstate);
16912 if (PyErr_Occurred()) SWIG_fail;
16913 }
16914 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16915 return resultobj;
16916 fail:
16917 return NULL;
16918 }
16919
16920
16921 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16922 PyObject *obj;
16923 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16924 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16925 return SWIG_Py_Void();
16926 }
16927
16928 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16929 return SWIG_Python_InitShadowInstance(args);
16930 }
16931
16932 SWIGINTERN int NullImage_set(PyObject *) {
16933 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16934 return 1;
16935 }
16936
16937
16938 SWIGINTERN PyObject *NullImage_get(void) {
16939 PyObject *pyobj = 0;
16940
16941 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16942 return pyobj;
16943 }
16944
16945
16946 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16947 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16948 return 1;
16949 }
16950
16951
16952 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16953 PyObject *pyobj = 0;
16954
16955 {
16956 #if wxUSE_UNICODE
16957 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16958 #else
16959 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16960 #endif
16961 }
16962 return pyobj;
16963 }
16964
16965
16966 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16967 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16968 return 1;
16969 }
16970
16971
16972 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16973 PyObject *pyobj = 0;
16974
16975 {
16976 #if wxUSE_UNICODE
16977 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16978 #else
16979 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16980 #endif
16981 }
16982 return pyobj;
16983 }
16984
16985
16986 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16987 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16988 return 1;
16989 }
16990
16991
16992 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16993 PyObject *pyobj = 0;
16994
16995 {
16996 #if wxUSE_UNICODE
16997 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16998 #else
16999 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17000 #endif
17001 }
17002 return pyobj;
17003 }
17004
17005
17006 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17007 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17008 return 1;
17009 }
17010
17011
17012 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17013 PyObject *pyobj = 0;
17014
17015 {
17016 #if wxUSE_UNICODE
17017 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17018 #else
17019 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17020 #endif
17021 }
17022 return pyobj;
17023 }
17024
17025
17026 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17027 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17028 return 1;
17029 }
17030
17031
17032 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17033 PyObject *pyobj = 0;
17034
17035 {
17036 #if wxUSE_UNICODE
17037 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17038 #else
17039 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17040 #endif
17041 }
17042 return pyobj;
17043 }
17044
17045
17046 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17047 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17048 return 1;
17049 }
17050
17051
17052 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17053 PyObject *pyobj = 0;
17054
17055 {
17056 #if wxUSE_UNICODE
17057 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17058 #else
17059 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17060 #endif
17061 }
17062 return pyobj;
17063 }
17064
17065
17066 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17067 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17068 return 1;
17069 }
17070
17071
17072 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17073 PyObject *pyobj = 0;
17074
17075 {
17076 #if wxUSE_UNICODE
17077 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17078 #else
17079 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17080 #endif
17081 }
17082 return pyobj;
17083 }
17084
17085
17086 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17087 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17088 return 1;
17089 }
17090
17091
17092 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17093 PyObject *pyobj = 0;
17094
17095 {
17096 #if wxUSE_UNICODE
17097 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17098 #else
17099 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17100 #endif
17101 }
17102 return pyobj;
17103 }
17104
17105
17106 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17107 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17108 return 1;
17109 }
17110
17111
17112 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17113 PyObject *pyobj = 0;
17114
17115 {
17116 #if wxUSE_UNICODE
17117 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17118 #else
17119 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17120 #endif
17121 }
17122 return pyobj;
17123 }
17124
17125
17126 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17127 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17128 return 1;
17129 }
17130
17131
17132 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17133 PyObject *pyobj = 0;
17134
17135 {
17136 #if wxUSE_UNICODE
17137 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17138 #else
17139 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17140 #endif
17141 }
17142 return pyobj;
17143 }
17144
17145
17146 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17147 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17148 return 1;
17149 }
17150
17151
17152 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17153 PyObject *pyobj = 0;
17154
17155 {
17156 #if wxUSE_UNICODE
17157 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17158 #else
17159 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17160 #endif
17161 }
17162 return pyobj;
17163 }
17164
17165
17166 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17167 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17168 return 1;
17169 }
17170
17171
17172 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17173 PyObject *pyobj = 0;
17174
17175 {
17176 #if wxUSE_UNICODE
17177 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17178 #else
17179 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17180 #endif
17181 }
17182 return pyobj;
17183 }
17184
17185
17186 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17187 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17188 return 1;
17189 }
17190
17191
17192 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17193 PyObject *pyobj = 0;
17194
17195 {
17196 #if wxUSE_UNICODE
17197 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17198 #else
17199 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17200 #endif
17201 }
17202 return pyobj;
17203 }
17204
17205
17206 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17207 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17208 return 1;
17209 }
17210
17211
17212 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17213 PyObject *pyobj = 0;
17214
17215 {
17216 #if wxUSE_UNICODE
17217 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17218 #else
17219 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17220 #endif
17221 }
17222 return pyobj;
17223 }
17224
17225
17226 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17227 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17228 return 1;
17229 }
17230
17231
17232 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17233 PyObject *pyobj = 0;
17234
17235 {
17236 #if wxUSE_UNICODE
17237 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17238 #else
17239 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17240 #endif
17241 }
17242 return pyobj;
17243 }
17244
17245
17246 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17247 PyObject *resultobj = 0;
17248 wxBMPHandler *result = 0 ;
17249
17250 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17251 {
17252 PyThreadState* __tstate = wxPyBeginAllowThreads();
17253 result = (wxBMPHandler *)new wxBMPHandler();
17254 wxPyEndAllowThreads(__tstate);
17255 if (PyErr_Occurred()) SWIG_fail;
17256 }
17257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17258 return resultobj;
17259 fail:
17260 return NULL;
17261 }
17262
17263
17264 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17265 PyObject *obj;
17266 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17267 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17268 return SWIG_Py_Void();
17269 }
17270
17271 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17272 return SWIG_Python_InitShadowInstance(args);
17273 }
17274
17275 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17276 PyObject *resultobj = 0;
17277 wxICOHandler *result = 0 ;
17278
17279 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17280 {
17281 PyThreadState* __tstate = wxPyBeginAllowThreads();
17282 result = (wxICOHandler *)new wxICOHandler();
17283 wxPyEndAllowThreads(__tstate);
17284 if (PyErr_Occurred()) SWIG_fail;
17285 }
17286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17287 return resultobj;
17288 fail:
17289 return NULL;
17290 }
17291
17292
17293 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17294 PyObject *obj;
17295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17296 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17297 return SWIG_Py_Void();
17298 }
17299
17300 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17301 return SWIG_Python_InitShadowInstance(args);
17302 }
17303
17304 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17305 PyObject *resultobj = 0;
17306 wxCURHandler *result = 0 ;
17307
17308 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17309 {
17310 PyThreadState* __tstate = wxPyBeginAllowThreads();
17311 result = (wxCURHandler *)new wxCURHandler();
17312 wxPyEndAllowThreads(__tstate);
17313 if (PyErr_Occurred()) SWIG_fail;
17314 }
17315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17316 return resultobj;
17317 fail:
17318 return NULL;
17319 }
17320
17321
17322 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17323 PyObject *obj;
17324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17325 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17326 return SWIG_Py_Void();
17327 }
17328
17329 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17330 return SWIG_Python_InitShadowInstance(args);
17331 }
17332
17333 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17334 PyObject *resultobj = 0;
17335 wxANIHandler *result = 0 ;
17336
17337 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17338 {
17339 PyThreadState* __tstate = wxPyBeginAllowThreads();
17340 result = (wxANIHandler *)new wxANIHandler();
17341 wxPyEndAllowThreads(__tstate);
17342 if (PyErr_Occurred()) SWIG_fail;
17343 }
17344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17345 return resultobj;
17346 fail:
17347 return NULL;
17348 }
17349
17350
17351 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17352 PyObject *obj;
17353 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17354 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17355 return SWIG_Py_Void();
17356 }
17357
17358 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17359 return SWIG_Python_InitShadowInstance(args);
17360 }
17361
17362 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17363 PyObject *resultobj = 0;
17364 wxPNGHandler *result = 0 ;
17365
17366 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17367 {
17368 PyThreadState* __tstate = wxPyBeginAllowThreads();
17369 result = (wxPNGHandler *)new wxPNGHandler();
17370 wxPyEndAllowThreads(__tstate);
17371 if (PyErr_Occurred()) SWIG_fail;
17372 }
17373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17374 return resultobj;
17375 fail:
17376 return NULL;
17377 }
17378
17379
17380 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17381 PyObject *obj;
17382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17383 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17384 return SWIG_Py_Void();
17385 }
17386
17387 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17388 return SWIG_Python_InitShadowInstance(args);
17389 }
17390
17391 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17392 PyObject *resultobj = 0;
17393 wxGIFHandler *result = 0 ;
17394
17395 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17396 {
17397 PyThreadState* __tstate = wxPyBeginAllowThreads();
17398 result = (wxGIFHandler *)new wxGIFHandler();
17399 wxPyEndAllowThreads(__tstate);
17400 if (PyErr_Occurred()) SWIG_fail;
17401 }
17402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17403 return resultobj;
17404 fail:
17405 return NULL;
17406 }
17407
17408
17409 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17410 PyObject *obj;
17411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17412 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17413 return SWIG_Py_Void();
17414 }
17415
17416 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17417 return SWIG_Python_InitShadowInstance(args);
17418 }
17419
17420 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17421 PyObject *resultobj = 0;
17422 wxPCXHandler *result = 0 ;
17423
17424 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17425 {
17426 PyThreadState* __tstate = wxPyBeginAllowThreads();
17427 result = (wxPCXHandler *)new wxPCXHandler();
17428 wxPyEndAllowThreads(__tstate);
17429 if (PyErr_Occurred()) SWIG_fail;
17430 }
17431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17432 return resultobj;
17433 fail:
17434 return NULL;
17435 }
17436
17437
17438 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17439 PyObject *obj;
17440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17441 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17442 return SWIG_Py_Void();
17443 }
17444
17445 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17446 return SWIG_Python_InitShadowInstance(args);
17447 }
17448
17449 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17450 PyObject *resultobj = 0;
17451 wxJPEGHandler *result = 0 ;
17452
17453 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17454 {
17455 PyThreadState* __tstate = wxPyBeginAllowThreads();
17456 result = (wxJPEGHandler *)new wxJPEGHandler();
17457 wxPyEndAllowThreads(__tstate);
17458 if (PyErr_Occurred()) SWIG_fail;
17459 }
17460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17461 return resultobj;
17462 fail:
17463 return NULL;
17464 }
17465
17466
17467 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17468 PyObject *obj;
17469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17470 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17471 return SWIG_Py_Void();
17472 }
17473
17474 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17475 return SWIG_Python_InitShadowInstance(args);
17476 }
17477
17478 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17479 PyObject *resultobj = 0;
17480 wxPNMHandler *result = 0 ;
17481
17482 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17483 {
17484 PyThreadState* __tstate = wxPyBeginAllowThreads();
17485 result = (wxPNMHandler *)new wxPNMHandler();
17486 wxPyEndAllowThreads(__tstate);
17487 if (PyErr_Occurred()) SWIG_fail;
17488 }
17489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17490 return resultobj;
17491 fail:
17492 return NULL;
17493 }
17494
17495
17496 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17497 PyObject *obj;
17498 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17499 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17500 return SWIG_Py_Void();
17501 }
17502
17503 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17504 return SWIG_Python_InitShadowInstance(args);
17505 }
17506
17507 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17508 PyObject *resultobj = 0;
17509 wxXPMHandler *result = 0 ;
17510
17511 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17512 {
17513 PyThreadState* __tstate = wxPyBeginAllowThreads();
17514 result = (wxXPMHandler *)new wxXPMHandler();
17515 wxPyEndAllowThreads(__tstate);
17516 if (PyErr_Occurred()) SWIG_fail;
17517 }
17518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17519 return resultobj;
17520 fail:
17521 return NULL;
17522 }
17523
17524
17525 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17526 PyObject *obj;
17527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17528 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17529 return SWIG_Py_Void();
17530 }
17531
17532 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17533 return SWIG_Python_InitShadowInstance(args);
17534 }
17535
17536 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17537 PyObject *resultobj = 0;
17538 wxTIFFHandler *result = 0 ;
17539
17540 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17541 {
17542 PyThreadState* __tstate = wxPyBeginAllowThreads();
17543 result = (wxTIFFHandler *)new wxTIFFHandler();
17544 wxPyEndAllowThreads(__tstate);
17545 if (PyErr_Occurred()) SWIG_fail;
17546 }
17547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17548 return resultobj;
17549 fail:
17550 return NULL;
17551 }
17552
17553
17554 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17555 PyObject *obj;
17556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17557 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17558 return SWIG_Py_Void();
17559 }
17560
17561 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17562 return SWIG_Python_InitShadowInstance(args);
17563 }
17564
17565 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17566 PyObject *resultobj = 0;
17567 wxImage *arg1 = 0 ;
17568 wxImage *arg2 = 0 ;
17569 int arg3 = (int) 236 ;
17570 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17571 bool result;
17572 void *argp1 = 0 ;
17573 int res1 = 0 ;
17574 void *argp2 = 0 ;
17575 int res2 = 0 ;
17576 int val3 ;
17577 int ecode3 = 0 ;
17578 int val4 ;
17579 int ecode4 = 0 ;
17580 PyObject * obj0 = 0 ;
17581 PyObject * obj1 = 0 ;
17582 PyObject * obj2 = 0 ;
17583 PyObject * obj3 = 0 ;
17584 char * kwnames[] = {
17585 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17586 };
17587
17588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17589 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17590 if (!SWIG_IsOK(res1)) {
17591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17592 }
17593 if (!argp1) {
17594 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17595 }
17596 arg1 = reinterpret_cast< wxImage * >(argp1);
17597 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17598 if (!SWIG_IsOK(res2)) {
17599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17600 }
17601 if (!argp2) {
17602 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17603 }
17604 arg2 = reinterpret_cast< wxImage * >(argp2);
17605 if (obj2) {
17606 ecode3 = SWIG_AsVal_int(obj2, &val3);
17607 if (!SWIG_IsOK(ecode3)) {
17608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17609 }
17610 arg3 = static_cast< int >(val3);
17611 }
17612 if (obj3) {
17613 ecode4 = SWIG_AsVal_int(obj3, &val4);
17614 if (!SWIG_IsOK(ecode4)) {
17615 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17616 }
17617 arg4 = static_cast< int >(val4);
17618 }
17619 {
17620 PyThreadState* __tstate = wxPyBeginAllowThreads();
17621 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17622 wxPyEndAllowThreads(__tstate);
17623 if (PyErr_Occurred()) SWIG_fail;
17624 }
17625 {
17626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17627 }
17628 return resultobj;
17629 fail:
17630 return NULL;
17631 }
17632
17633
17634 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17635 PyObject *obj;
17636 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17637 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17638 return SWIG_Py_Void();
17639 }
17640
17641 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17642 PyObject *resultobj = 0;
17643 wxEvtHandler *result = 0 ;
17644
17645 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17646 {
17647 PyThreadState* __tstate = wxPyBeginAllowThreads();
17648 result = (wxEvtHandler *)new wxEvtHandler();
17649 wxPyEndAllowThreads(__tstate);
17650 if (PyErr_Occurred()) SWIG_fail;
17651 }
17652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17653 return resultobj;
17654 fail:
17655 return NULL;
17656 }
17657
17658
17659 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17660 PyObject *resultobj = 0;
17661 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17662 wxEvtHandler *result = 0 ;
17663 void *argp1 = 0 ;
17664 int res1 = 0 ;
17665 PyObject *swig_obj[1] ;
17666
17667 if (!args) SWIG_fail;
17668 swig_obj[0] = args;
17669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17670 if (!SWIG_IsOK(res1)) {
17671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17672 }
17673 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17674 {
17675 PyThreadState* __tstate = wxPyBeginAllowThreads();
17676 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17677 wxPyEndAllowThreads(__tstate);
17678 if (PyErr_Occurred()) SWIG_fail;
17679 }
17680 {
17681 resultobj = wxPyMake_wxObject(result, 0);
17682 }
17683 return resultobj;
17684 fail:
17685 return NULL;
17686 }
17687
17688
17689 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17690 PyObject *resultobj = 0;
17691 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17692 wxEvtHandler *result = 0 ;
17693 void *argp1 = 0 ;
17694 int res1 = 0 ;
17695 PyObject *swig_obj[1] ;
17696
17697 if (!args) SWIG_fail;
17698 swig_obj[0] = args;
17699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17700 if (!SWIG_IsOK(res1)) {
17701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17702 }
17703 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17704 {
17705 PyThreadState* __tstate = wxPyBeginAllowThreads();
17706 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17707 wxPyEndAllowThreads(__tstate);
17708 if (PyErr_Occurred()) SWIG_fail;
17709 }
17710 {
17711 resultobj = wxPyMake_wxObject(result, 0);
17712 }
17713 return resultobj;
17714 fail:
17715 return NULL;
17716 }
17717
17718
17719 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17720 PyObject *resultobj = 0;
17721 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17722 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17723 void *argp1 = 0 ;
17724 int res1 = 0 ;
17725 void *argp2 = 0 ;
17726 int res2 = 0 ;
17727 PyObject * obj0 = 0 ;
17728 PyObject * obj1 = 0 ;
17729 char * kwnames[] = {
17730 (char *) "self",(char *) "handler", NULL
17731 };
17732
17733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17735 if (!SWIG_IsOK(res1)) {
17736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17737 }
17738 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17739 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17740 if (!SWIG_IsOK(res2)) {
17741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17742 }
17743 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17744 {
17745 PyThreadState* __tstate = wxPyBeginAllowThreads();
17746 (arg1)->SetNextHandler(arg2);
17747 wxPyEndAllowThreads(__tstate);
17748 if (PyErr_Occurred()) SWIG_fail;
17749 }
17750 resultobj = SWIG_Py_Void();
17751 return resultobj;
17752 fail:
17753 return NULL;
17754 }
17755
17756
17757 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17758 PyObject *resultobj = 0;
17759 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17760 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17761 void *argp1 = 0 ;
17762 int res1 = 0 ;
17763 void *argp2 = 0 ;
17764 int res2 = 0 ;
17765 PyObject * obj0 = 0 ;
17766 PyObject * obj1 = 0 ;
17767 char * kwnames[] = {
17768 (char *) "self",(char *) "handler", NULL
17769 };
17770
17771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17773 if (!SWIG_IsOK(res1)) {
17774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17775 }
17776 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17777 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17778 if (!SWIG_IsOK(res2)) {
17779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17780 }
17781 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17782 {
17783 PyThreadState* __tstate = wxPyBeginAllowThreads();
17784 (arg1)->SetPreviousHandler(arg2);
17785 wxPyEndAllowThreads(__tstate);
17786 if (PyErr_Occurred()) SWIG_fail;
17787 }
17788 resultobj = SWIG_Py_Void();
17789 return resultobj;
17790 fail:
17791 return NULL;
17792 }
17793
17794
17795 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17796 PyObject *resultobj = 0;
17797 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17798 bool result;
17799 void *argp1 = 0 ;
17800 int res1 = 0 ;
17801 PyObject *swig_obj[1] ;
17802
17803 if (!args) SWIG_fail;
17804 swig_obj[0] = args;
17805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17806 if (!SWIG_IsOK(res1)) {
17807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17808 }
17809 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17810 {
17811 PyThreadState* __tstate = wxPyBeginAllowThreads();
17812 result = (bool)(arg1)->GetEvtHandlerEnabled();
17813 wxPyEndAllowThreads(__tstate);
17814 if (PyErr_Occurred()) SWIG_fail;
17815 }
17816 {
17817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17818 }
17819 return resultobj;
17820 fail:
17821 return NULL;
17822 }
17823
17824
17825 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17826 PyObject *resultobj = 0;
17827 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17828 bool arg2 ;
17829 void *argp1 = 0 ;
17830 int res1 = 0 ;
17831 bool val2 ;
17832 int ecode2 = 0 ;
17833 PyObject * obj0 = 0 ;
17834 PyObject * obj1 = 0 ;
17835 char * kwnames[] = {
17836 (char *) "self",(char *) "enabled", NULL
17837 };
17838
17839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17841 if (!SWIG_IsOK(res1)) {
17842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17843 }
17844 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17845 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17846 if (!SWIG_IsOK(ecode2)) {
17847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17848 }
17849 arg2 = static_cast< bool >(val2);
17850 {
17851 PyThreadState* __tstate = wxPyBeginAllowThreads();
17852 (arg1)->SetEvtHandlerEnabled(arg2);
17853 wxPyEndAllowThreads(__tstate);
17854 if (PyErr_Occurred()) SWIG_fail;
17855 }
17856 resultobj = SWIG_Py_Void();
17857 return resultobj;
17858 fail:
17859 return NULL;
17860 }
17861
17862
17863 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17864 PyObject *resultobj = 0;
17865 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17866 wxEvent *arg2 = 0 ;
17867 bool result;
17868 void *argp1 = 0 ;
17869 int res1 = 0 ;
17870 void *argp2 = 0 ;
17871 int res2 = 0 ;
17872 PyObject * obj0 = 0 ;
17873 PyObject * obj1 = 0 ;
17874 char * kwnames[] = {
17875 (char *) "self",(char *) "event", NULL
17876 };
17877
17878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17880 if (!SWIG_IsOK(res1)) {
17881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17882 }
17883 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17884 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17885 if (!SWIG_IsOK(res2)) {
17886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17887 }
17888 if (!argp2) {
17889 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17890 }
17891 arg2 = reinterpret_cast< wxEvent * >(argp2);
17892 {
17893 PyThreadState* __tstate = wxPyBeginAllowThreads();
17894 result = (bool)(arg1)->ProcessEvent(*arg2);
17895 wxPyEndAllowThreads(__tstate);
17896 if (PyErr_Occurred()) SWIG_fail;
17897 }
17898 {
17899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17900 }
17901 return resultobj;
17902 fail:
17903 return NULL;
17904 }
17905
17906
17907 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17908 PyObject *resultobj = 0;
17909 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17910 wxEvent *arg2 = 0 ;
17911 void *argp1 = 0 ;
17912 int res1 = 0 ;
17913 void *argp2 = 0 ;
17914 int res2 = 0 ;
17915 PyObject * obj0 = 0 ;
17916 PyObject * obj1 = 0 ;
17917 char * kwnames[] = {
17918 (char *) "self",(char *) "event", NULL
17919 };
17920
17921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17923 if (!SWIG_IsOK(res1)) {
17924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17925 }
17926 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17927 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17928 if (!SWIG_IsOK(res2)) {
17929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17930 }
17931 if (!argp2) {
17932 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17933 }
17934 arg2 = reinterpret_cast< wxEvent * >(argp2);
17935 {
17936 PyThreadState* __tstate = wxPyBeginAllowThreads();
17937 (arg1)->AddPendingEvent(*arg2);
17938 wxPyEndAllowThreads(__tstate);
17939 if (PyErr_Occurred()) SWIG_fail;
17940 }
17941 resultobj = SWIG_Py_Void();
17942 return resultobj;
17943 fail:
17944 return NULL;
17945 }
17946
17947
17948 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17949 PyObject *resultobj = 0;
17950 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17951 void *argp1 = 0 ;
17952 int res1 = 0 ;
17953 PyObject *swig_obj[1] ;
17954
17955 if (!args) SWIG_fail;
17956 swig_obj[0] = args;
17957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17958 if (!SWIG_IsOK(res1)) {
17959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17960 }
17961 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17962 {
17963 PyThreadState* __tstate = wxPyBeginAllowThreads();
17964 (arg1)->ProcessPendingEvents();
17965 wxPyEndAllowThreads(__tstate);
17966 if (PyErr_Occurred()) SWIG_fail;
17967 }
17968 resultobj = SWIG_Py_Void();
17969 return resultobj;
17970 fail:
17971 return NULL;
17972 }
17973
17974
17975 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17976 PyObject *resultobj = 0;
17977 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17978 int arg2 ;
17979 int arg3 ;
17980 int arg4 ;
17981 PyObject *arg5 = (PyObject *) 0 ;
17982 void *argp1 = 0 ;
17983 int res1 = 0 ;
17984 int val2 ;
17985 int ecode2 = 0 ;
17986 int val3 ;
17987 int ecode3 = 0 ;
17988 int val4 ;
17989 int ecode4 = 0 ;
17990 PyObject * obj0 = 0 ;
17991 PyObject * obj1 = 0 ;
17992 PyObject * obj2 = 0 ;
17993 PyObject * obj3 = 0 ;
17994 PyObject * obj4 = 0 ;
17995 char * kwnames[] = {
17996 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17997 };
17998
17999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18001 if (!SWIG_IsOK(res1)) {
18002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18003 }
18004 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18005 ecode2 = SWIG_AsVal_int(obj1, &val2);
18006 if (!SWIG_IsOK(ecode2)) {
18007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18008 }
18009 arg2 = static_cast< int >(val2);
18010 ecode3 = SWIG_AsVal_int(obj2, &val3);
18011 if (!SWIG_IsOK(ecode3)) {
18012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18013 }
18014 arg3 = static_cast< int >(val3);
18015 ecode4 = SWIG_AsVal_int(obj3, &val4);
18016 if (!SWIG_IsOK(ecode4)) {
18017 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18018 }
18019 arg4 = static_cast< int >(val4);
18020 arg5 = obj4;
18021 {
18022 PyThreadState* __tstate = wxPyBeginAllowThreads();
18023 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18024 wxPyEndAllowThreads(__tstate);
18025 if (PyErr_Occurred()) SWIG_fail;
18026 }
18027 resultobj = SWIG_Py_Void();
18028 return resultobj;
18029 fail:
18030 return NULL;
18031 }
18032
18033
18034 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18035 PyObject *resultobj = 0;
18036 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18037 int arg2 ;
18038 int arg3 = (int) -1 ;
18039 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18040 bool result;
18041 void *argp1 = 0 ;
18042 int res1 = 0 ;
18043 int val2 ;
18044 int ecode2 = 0 ;
18045 int val3 ;
18046 int ecode3 = 0 ;
18047 int val4 ;
18048 int ecode4 = 0 ;
18049 PyObject * obj0 = 0 ;
18050 PyObject * obj1 = 0 ;
18051 PyObject * obj2 = 0 ;
18052 PyObject * obj3 = 0 ;
18053 char * kwnames[] = {
18054 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18055 };
18056
18057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18059 if (!SWIG_IsOK(res1)) {
18060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18061 }
18062 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18063 ecode2 = SWIG_AsVal_int(obj1, &val2);
18064 if (!SWIG_IsOK(ecode2)) {
18065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18066 }
18067 arg2 = static_cast< int >(val2);
18068 if (obj2) {
18069 ecode3 = SWIG_AsVal_int(obj2, &val3);
18070 if (!SWIG_IsOK(ecode3)) {
18071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18072 }
18073 arg3 = static_cast< int >(val3);
18074 }
18075 if (obj3) {
18076 ecode4 = SWIG_AsVal_int(obj3, &val4);
18077 if (!SWIG_IsOK(ecode4)) {
18078 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18079 }
18080 arg4 = static_cast< wxEventType >(val4);
18081 }
18082 {
18083 PyThreadState* __tstate = wxPyBeginAllowThreads();
18084 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18085 wxPyEndAllowThreads(__tstate);
18086 if (PyErr_Occurred()) SWIG_fail;
18087 }
18088 {
18089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18090 }
18091 return resultobj;
18092 fail:
18093 return NULL;
18094 }
18095
18096
18097 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18098 PyObject *resultobj = 0;
18099 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18100 PyObject *arg2 = (PyObject *) 0 ;
18101 bool arg3 = (bool) true ;
18102 void *argp1 = 0 ;
18103 int res1 = 0 ;
18104 bool val3 ;
18105 int ecode3 = 0 ;
18106 PyObject * obj0 = 0 ;
18107 PyObject * obj1 = 0 ;
18108 PyObject * obj2 = 0 ;
18109 char * kwnames[] = {
18110 (char *) "self",(char *) "_self",(char *) "incref", NULL
18111 };
18112
18113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18115 if (!SWIG_IsOK(res1)) {
18116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18117 }
18118 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18119 arg2 = obj1;
18120 if (obj2) {
18121 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18122 if (!SWIG_IsOK(ecode3)) {
18123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18124 }
18125 arg3 = static_cast< bool >(val3);
18126 }
18127 {
18128 PyThreadState* __tstate = wxPyBeginAllowThreads();
18129 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18130 wxPyEndAllowThreads(__tstate);
18131 if (PyErr_Occurred()) SWIG_fail;
18132 }
18133 resultobj = SWIG_Py_Void();
18134 return resultobj;
18135 fail:
18136 return NULL;
18137 }
18138
18139
18140 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18141 PyObject *obj;
18142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18143 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18144 return SWIG_Py_Void();
18145 }
18146
18147 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18148 return SWIG_Python_InitShadowInstance(args);
18149 }
18150
18151 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18152 PyObject *resultobj = 0;
18153 wxEventType result;
18154
18155 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18156 {
18157 PyThreadState* __tstate = wxPyBeginAllowThreads();
18158 result = (wxEventType)wxNewEventType();
18159 wxPyEndAllowThreads(__tstate);
18160 if (PyErr_Occurred()) SWIG_fail;
18161 }
18162 resultobj = SWIG_From_int(static_cast< int >(result));
18163 return resultobj;
18164 fail:
18165 return NULL;
18166 }
18167
18168
18169 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18170 PyObject *resultobj = 0;
18171 wxEvent *arg1 = (wxEvent *) 0 ;
18172 void *argp1 = 0 ;
18173 int res1 = 0 ;
18174 PyObject *swig_obj[1] ;
18175
18176 if (!args) SWIG_fail;
18177 swig_obj[0] = args;
18178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18179 if (!SWIG_IsOK(res1)) {
18180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18181 }
18182 arg1 = reinterpret_cast< wxEvent * >(argp1);
18183 {
18184 PyThreadState* __tstate = wxPyBeginAllowThreads();
18185 delete arg1;
18186
18187 wxPyEndAllowThreads(__tstate);
18188 if (PyErr_Occurred()) SWIG_fail;
18189 }
18190 resultobj = SWIG_Py_Void();
18191 return resultobj;
18192 fail:
18193 return NULL;
18194 }
18195
18196
18197 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18198 PyObject *resultobj = 0;
18199 wxEvent *arg1 = (wxEvent *) 0 ;
18200 wxEventType arg2 ;
18201 void *argp1 = 0 ;
18202 int res1 = 0 ;
18203 int val2 ;
18204 int ecode2 = 0 ;
18205 PyObject * obj0 = 0 ;
18206 PyObject * obj1 = 0 ;
18207 char * kwnames[] = {
18208 (char *) "self",(char *) "typ", NULL
18209 };
18210
18211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18213 if (!SWIG_IsOK(res1)) {
18214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18215 }
18216 arg1 = reinterpret_cast< wxEvent * >(argp1);
18217 ecode2 = SWIG_AsVal_int(obj1, &val2);
18218 if (!SWIG_IsOK(ecode2)) {
18219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18220 }
18221 arg2 = static_cast< wxEventType >(val2);
18222 {
18223 PyThreadState* __tstate = wxPyBeginAllowThreads();
18224 (arg1)->SetEventType(arg2);
18225 wxPyEndAllowThreads(__tstate);
18226 if (PyErr_Occurred()) SWIG_fail;
18227 }
18228 resultobj = SWIG_Py_Void();
18229 return resultobj;
18230 fail:
18231 return NULL;
18232 }
18233
18234
18235 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18236 PyObject *resultobj = 0;
18237 wxEvent *arg1 = (wxEvent *) 0 ;
18238 wxEventType result;
18239 void *argp1 = 0 ;
18240 int res1 = 0 ;
18241 PyObject *swig_obj[1] ;
18242
18243 if (!args) SWIG_fail;
18244 swig_obj[0] = args;
18245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18246 if (!SWIG_IsOK(res1)) {
18247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18248 }
18249 arg1 = reinterpret_cast< wxEvent * >(argp1);
18250 {
18251 PyThreadState* __tstate = wxPyBeginAllowThreads();
18252 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18253 wxPyEndAllowThreads(__tstate);
18254 if (PyErr_Occurred()) SWIG_fail;
18255 }
18256 resultobj = SWIG_From_int(static_cast< int >(result));
18257 return resultobj;
18258 fail:
18259 return NULL;
18260 }
18261
18262
18263 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18264 PyObject *resultobj = 0;
18265 wxEvent *arg1 = (wxEvent *) 0 ;
18266 wxObject *result = 0 ;
18267 void *argp1 = 0 ;
18268 int res1 = 0 ;
18269 PyObject *swig_obj[1] ;
18270
18271 if (!args) SWIG_fail;
18272 swig_obj[0] = args;
18273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18274 if (!SWIG_IsOK(res1)) {
18275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18276 }
18277 arg1 = reinterpret_cast< wxEvent * >(argp1);
18278 {
18279 PyThreadState* __tstate = wxPyBeginAllowThreads();
18280 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18281 wxPyEndAllowThreads(__tstate);
18282 if (PyErr_Occurred()) SWIG_fail;
18283 }
18284 {
18285 resultobj = wxPyMake_wxObject(result, (bool)0);
18286 }
18287 return resultobj;
18288 fail:
18289 return NULL;
18290 }
18291
18292
18293 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18294 PyObject *resultobj = 0;
18295 wxEvent *arg1 = (wxEvent *) 0 ;
18296 wxObject *arg2 = (wxObject *) 0 ;
18297 void *argp1 = 0 ;
18298 int res1 = 0 ;
18299 void *argp2 = 0 ;
18300 int res2 = 0 ;
18301 PyObject * obj0 = 0 ;
18302 PyObject * obj1 = 0 ;
18303 char * kwnames[] = {
18304 (char *) "self",(char *) "obj", NULL
18305 };
18306
18307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18309 if (!SWIG_IsOK(res1)) {
18310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18311 }
18312 arg1 = reinterpret_cast< wxEvent * >(argp1);
18313 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18314 if (!SWIG_IsOK(res2)) {
18315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18316 }
18317 arg2 = reinterpret_cast< wxObject * >(argp2);
18318 {
18319 PyThreadState* __tstate = wxPyBeginAllowThreads();
18320 (arg1)->SetEventObject(arg2);
18321 wxPyEndAllowThreads(__tstate);
18322 if (PyErr_Occurred()) SWIG_fail;
18323 }
18324 resultobj = SWIG_Py_Void();
18325 return resultobj;
18326 fail:
18327 return NULL;
18328 }
18329
18330
18331 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18332 PyObject *resultobj = 0;
18333 wxEvent *arg1 = (wxEvent *) 0 ;
18334 long result;
18335 void *argp1 = 0 ;
18336 int res1 = 0 ;
18337 PyObject *swig_obj[1] ;
18338
18339 if (!args) SWIG_fail;
18340 swig_obj[0] = args;
18341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18342 if (!SWIG_IsOK(res1)) {
18343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18344 }
18345 arg1 = reinterpret_cast< wxEvent * >(argp1);
18346 {
18347 PyThreadState* __tstate = wxPyBeginAllowThreads();
18348 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18349 wxPyEndAllowThreads(__tstate);
18350 if (PyErr_Occurred()) SWIG_fail;
18351 }
18352 resultobj = SWIG_From_long(static_cast< long >(result));
18353 return resultobj;
18354 fail:
18355 return NULL;
18356 }
18357
18358
18359 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18360 PyObject *resultobj = 0;
18361 wxEvent *arg1 = (wxEvent *) 0 ;
18362 long arg2 = (long) 0 ;
18363 void *argp1 = 0 ;
18364 int res1 = 0 ;
18365 long val2 ;
18366 int ecode2 = 0 ;
18367 PyObject * obj0 = 0 ;
18368 PyObject * obj1 = 0 ;
18369 char * kwnames[] = {
18370 (char *) "self",(char *) "ts", NULL
18371 };
18372
18373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18375 if (!SWIG_IsOK(res1)) {
18376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18377 }
18378 arg1 = reinterpret_cast< wxEvent * >(argp1);
18379 if (obj1) {
18380 ecode2 = SWIG_AsVal_long(obj1, &val2);
18381 if (!SWIG_IsOK(ecode2)) {
18382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18383 }
18384 arg2 = static_cast< long >(val2);
18385 }
18386 {
18387 PyThreadState* __tstate = wxPyBeginAllowThreads();
18388 (arg1)->SetTimestamp(arg2);
18389 wxPyEndAllowThreads(__tstate);
18390 if (PyErr_Occurred()) SWIG_fail;
18391 }
18392 resultobj = SWIG_Py_Void();
18393 return resultobj;
18394 fail:
18395 return NULL;
18396 }
18397
18398
18399 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18400 PyObject *resultobj = 0;
18401 wxEvent *arg1 = (wxEvent *) 0 ;
18402 int result;
18403 void *argp1 = 0 ;
18404 int res1 = 0 ;
18405 PyObject *swig_obj[1] ;
18406
18407 if (!args) SWIG_fail;
18408 swig_obj[0] = args;
18409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18410 if (!SWIG_IsOK(res1)) {
18411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18412 }
18413 arg1 = reinterpret_cast< wxEvent * >(argp1);
18414 {
18415 PyThreadState* __tstate = wxPyBeginAllowThreads();
18416 result = (int)((wxEvent const *)arg1)->GetId();
18417 wxPyEndAllowThreads(__tstate);
18418 if (PyErr_Occurred()) SWIG_fail;
18419 }
18420 resultobj = SWIG_From_int(static_cast< int >(result));
18421 return resultobj;
18422 fail:
18423 return NULL;
18424 }
18425
18426
18427 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18428 PyObject *resultobj = 0;
18429 wxEvent *arg1 = (wxEvent *) 0 ;
18430 int arg2 ;
18431 void *argp1 = 0 ;
18432 int res1 = 0 ;
18433 int val2 ;
18434 int ecode2 = 0 ;
18435 PyObject * obj0 = 0 ;
18436 PyObject * obj1 = 0 ;
18437 char * kwnames[] = {
18438 (char *) "self",(char *) "Id", NULL
18439 };
18440
18441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18443 if (!SWIG_IsOK(res1)) {
18444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18445 }
18446 arg1 = reinterpret_cast< wxEvent * >(argp1);
18447 ecode2 = SWIG_AsVal_int(obj1, &val2);
18448 if (!SWIG_IsOK(ecode2)) {
18449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18450 }
18451 arg2 = static_cast< int >(val2);
18452 {
18453 PyThreadState* __tstate = wxPyBeginAllowThreads();
18454 (arg1)->SetId(arg2);
18455 wxPyEndAllowThreads(__tstate);
18456 if (PyErr_Occurred()) SWIG_fail;
18457 }
18458 resultobj = SWIG_Py_Void();
18459 return resultobj;
18460 fail:
18461 return NULL;
18462 }
18463
18464
18465 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18466 PyObject *resultobj = 0;
18467 wxEvent *arg1 = (wxEvent *) 0 ;
18468 bool result;
18469 void *argp1 = 0 ;
18470 int res1 = 0 ;
18471 PyObject *swig_obj[1] ;
18472
18473 if (!args) SWIG_fail;
18474 swig_obj[0] = args;
18475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18476 if (!SWIG_IsOK(res1)) {
18477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18478 }
18479 arg1 = reinterpret_cast< wxEvent * >(argp1);
18480 {
18481 PyThreadState* __tstate = wxPyBeginAllowThreads();
18482 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18483 wxPyEndAllowThreads(__tstate);
18484 if (PyErr_Occurred()) SWIG_fail;
18485 }
18486 {
18487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18488 }
18489 return resultobj;
18490 fail:
18491 return NULL;
18492 }
18493
18494
18495 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18496 PyObject *resultobj = 0;
18497 wxEvent *arg1 = (wxEvent *) 0 ;
18498 bool arg2 = (bool) true ;
18499 void *argp1 = 0 ;
18500 int res1 = 0 ;
18501 bool val2 ;
18502 int ecode2 = 0 ;
18503 PyObject * obj0 = 0 ;
18504 PyObject * obj1 = 0 ;
18505 char * kwnames[] = {
18506 (char *) "self",(char *) "skip", NULL
18507 };
18508
18509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18511 if (!SWIG_IsOK(res1)) {
18512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18513 }
18514 arg1 = reinterpret_cast< wxEvent * >(argp1);
18515 if (obj1) {
18516 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18517 if (!SWIG_IsOK(ecode2)) {
18518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18519 }
18520 arg2 = static_cast< bool >(val2);
18521 }
18522 {
18523 PyThreadState* __tstate = wxPyBeginAllowThreads();
18524 (arg1)->Skip(arg2);
18525 wxPyEndAllowThreads(__tstate);
18526 if (PyErr_Occurred()) SWIG_fail;
18527 }
18528 resultobj = SWIG_Py_Void();
18529 return resultobj;
18530 fail:
18531 return NULL;
18532 }
18533
18534
18535 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18536 PyObject *resultobj = 0;
18537 wxEvent *arg1 = (wxEvent *) 0 ;
18538 bool result;
18539 void *argp1 = 0 ;
18540 int res1 = 0 ;
18541 PyObject *swig_obj[1] ;
18542
18543 if (!args) SWIG_fail;
18544 swig_obj[0] = args;
18545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18546 if (!SWIG_IsOK(res1)) {
18547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18548 }
18549 arg1 = reinterpret_cast< wxEvent * >(argp1);
18550 {
18551 PyThreadState* __tstate = wxPyBeginAllowThreads();
18552 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18553 wxPyEndAllowThreads(__tstate);
18554 if (PyErr_Occurred()) SWIG_fail;
18555 }
18556 {
18557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18558 }
18559 return resultobj;
18560 fail:
18561 return NULL;
18562 }
18563
18564
18565 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18566 PyObject *resultobj = 0;
18567 wxEvent *arg1 = (wxEvent *) 0 ;
18568 bool result;
18569 void *argp1 = 0 ;
18570 int res1 = 0 ;
18571 PyObject *swig_obj[1] ;
18572
18573 if (!args) SWIG_fail;
18574 swig_obj[0] = args;
18575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18576 if (!SWIG_IsOK(res1)) {
18577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18578 }
18579 arg1 = reinterpret_cast< wxEvent * >(argp1);
18580 {
18581 PyThreadState* __tstate = wxPyBeginAllowThreads();
18582 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18583 wxPyEndAllowThreads(__tstate);
18584 if (PyErr_Occurred()) SWIG_fail;
18585 }
18586 {
18587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18588 }
18589 return resultobj;
18590 fail:
18591 return NULL;
18592 }
18593
18594
18595 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18596 PyObject *resultobj = 0;
18597 wxEvent *arg1 = (wxEvent *) 0 ;
18598 int result;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 PyObject *swig_obj[1] ;
18602
18603 if (!args) SWIG_fail;
18604 swig_obj[0] = args;
18605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18606 if (!SWIG_IsOK(res1)) {
18607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18608 }
18609 arg1 = reinterpret_cast< wxEvent * >(argp1);
18610 {
18611 PyThreadState* __tstate = wxPyBeginAllowThreads();
18612 result = (int)(arg1)->StopPropagation();
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 resultobj = SWIG_From_int(static_cast< int >(result));
18617 return resultobj;
18618 fail:
18619 return NULL;
18620 }
18621
18622
18623 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18624 PyObject *resultobj = 0;
18625 wxEvent *arg1 = (wxEvent *) 0 ;
18626 int arg2 ;
18627 void *argp1 = 0 ;
18628 int res1 = 0 ;
18629 int val2 ;
18630 int ecode2 = 0 ;
18631 PyObject * obj0 = 0 ;
18632 PyObject * obj1 = 0 ;
18633 char * kwnames[] = {
18634 (char *) "self",(char *) "propagationLevel", NULL
18635 };
18636
18637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18639 if (!SWIG_IsOK(res1)) {
18640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18641 }
18642 arg1 = reinterpret_cast< wxEvent * >(argp1);
18643 ecode2 = SWIG_AsVal_int(obj1, &val2);
18644 if (!SWIG_IsOK(ecode2)) {
18645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18646 }
18647 arg2 = static_cast< int >(val2);
18648 {
18649 PyThreadState* __tstate = wxPyBeginAllowThreads();
18650 (arg1)->ResumePropagation(arg2);
18651 wxPyEndAllowThreads(__tstate);
18652 if (PyErr_Occurred()) SWIG_fail;
18653 }
18654 resultobj = SWIG_Py_Void();
18655 return resultobj;
18656 fail:
18657 return NULL;
18658 }
18659
18660
18661 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18662 PyObject *resultobj = 0;
18663 wxEvent *arg1 = (wxEvent *) 0 ;
18664 wxEvent *result = 0 ;
18665 void *argp1 = 0 ;
18666 int res1 = 0 ;
18667 PyObject *swig_obj[1] ;
18668
18669 if (!args) SWIG_fail;
18670 swig_obj[0] = args;
18671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18672 if (!SWIG_IsOK(res1)) {
18673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18674 }
18675 arg1 = reinterpret_cast< wxEvent * >(argp1);
18676 {
18677 PyThreadState* __tstate = wxPyBeginAllowThreads();
18678 result = (wxEvent *)(arg1)->Clone();
18679 wxPyEndAllowThreads(__tstate);
18680 if (PyErr_Occurred()) SWIG_fail;
18681 }
18682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18683 return resultobj;
18684 fail:
18685 return NULL;
18686 }
18687
18688
18689 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18690 PyObject *obj;
18691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18692 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18693 return SWIG_Py_Void();
18694 }
18695
18696 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18697 PyObject *resultobj = 0;
18698 wxEvent *arg1 = 0 ;
18699 wxPropagationDisabler *result = 0 ;
18700 void *argp1 = 0 ;
18701 int res1 = 0 ;
18702 PyObject * obj0 = 0 ;
18703 char * kwnames[] = {
18704 (char *) "event", NULL
18705 };
18706
18707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18708 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18709 if (!SWIG_IsOK(res1)) {
18710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18711 }
18712 if (!argp1) {
18713 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18714 }
18715 arg1 = reinterpret_cast< wxEvent * >(argp1);
18716 {
18717 PyThreadState* __tstate = wxPyBeginAllowThreads();
18718 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18719 wxPyEndAllowThreads(__tstate);
18720 if (PyErr_Occurred()) SWIG_fail;
18721 }
18722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18723 return resultobj;
18724 fail:
18725 return NULL;
18726 }
18727
18728
18729 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18730 PyObject *resultobj = 0;
18731 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18732 void *argp1 = 0 ;
18733 int res1 = 0 ;
18734 PyObject *swig_obj[1] ;
18735
18736 if (!args) SWIG_fail;
18737 swig_obj[0] = args;
18738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18739 if (!SWIG_IsOK(res1)) {
18740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18741 }
18742 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18743 {
18744 PyThreadState* __tstate = wxPyBeginAllowThreads();
18745 delete arg1;
18746
18747 wxPyEndAllowThreads(__tstate);
18748 if (PyErr_Occurred()) SWIG_fail;
18749 }
18750 resultobj = SWIG_Py_Void();
18751 return resultobj;
18752 fail:
18753 return NULL;
18754 }
18755
18756
18757 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18758 PyObject *obj;
18759 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18760 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18761 return SWIG_Py_Void();
18762 }
18763
18764 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18765 return SWIG_Python_InitShadowInstance(args);
18766 }
18767
18768 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18769 PyObject *resultobj = 0;
18770 wxEvent *arg1 = 0 ;
18771 wxPropagateOnce *result = 0 ;
18772 void *argp1 = 0 ;
18773 int res1 = 0 ;
18774 PyObject * obj0 = 0 ;
18775 char * kwnames[] = {
18776 (char *) "event", NULL
18777 };
18778
18779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18780 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18781 if (!SWIG_IsOK(res1)) {
18782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18783 }
18784 if (!argp1) {
18785 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18786 }
18787 arg1 = reinterpret_cast< wxEvent * >(argp1);
18788 {
18789 PyThreadState* __tstate = wxPyBeginAllowThreads();
18790 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18791 wxPyEndAllowThreads(__tstate);
18792 if (PyErr_Occurred()) SWIG_fail;
18793 }
18794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18795 return resultobj;
18796 fail:
18797 return NULL;
18798 }
18799
18800
18801 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18802 PyObject *resultobj = 0;
18803 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18804 void *argp1 = 0 ;
18805 int res1 = 0 ;
18806 PyObject *swig_obj[1] ;
18807
18808 if (!args) SWIG_fail;
18809 swig_obj[0] = args;
18810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18811 if (!SWIG_IsOK(res1)) {
18812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18813 }
18814 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18815 {
18816 PyThreadState* __tstate = wxPyBeginAllowThreads();
18817 delete arg1;
18818
18819 wxPyEndAllowThreads(__tstate);
18820 if (PyErr_Occurred()) SWIG_fail;
18821 }
18822 resultobj = SWIG_Py_Void();
18823 return resultobj;
18824 fail:
18825 return NULL;
18826 }
18827
18828
18829 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18830 PyObject *obj;
18831 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18832 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18833 return SWIG_Py_Void();
18834 }
18835
18836 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18837 return SWIG_Python_InitShadowInstance(args);
18838 }
18839
18840 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18841 PyObject *resultobj = 0;
18842 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18843 int arg2 = (int) 0 ;
18844 wxCommandEvent *result = 0 ;
18845 int val1 ;
18846 int ecode1 = 0 ;
18847 int val2 ;
18848 int ecode2 = 0 ;
18849 PyObject * obj0 = 0 ;
18850 PyObject * obj1 = 0 ;
18851 char * kwnames[] = {
18852 (char *) "commandType",(char *) "winid", NULL
18853 };
18854
18855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18856 if (obj0) {
18857 ecode1 = SWIG_AsVal_int(obj0, &val1);
18858 if (!SWIG_IsOK(ecode1)) {
18859 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18860 }
18861 arg1 = static_cast< wxEventType >(val1);
18862 }
18863 if (obj1) {
18864 ecode2 = SWIG_AsVal_int(obj1, &val2);
18865 if (!SWIG_IsOK(ecode2)) {
18866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18867 }
18868 arg2 = static_cast< int >(val2);
18869 }
18870 {
18871 PyThreadState* __tstate = wxPyBeginAllowThreads();
18872 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18873 wxPyEndAllowThreads(__tstate);
18874 if (PyErr_Occurred()) SWIG_fail;
18875 }
18876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18877 return resultobj;
18878 fail:
18879 return NULL;
18880 }
18881
18882
18883 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18884 PyObject *resultobj = 0;
18885 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18886 int result;
18887 void *argp1 = 0 ;
18888 int res1 = 0 ;
18889 PyObject *swig_obj[1] ;
18890
18891 if (!args) SWIG_fail;
18892 swig_obj[0] = args;
18893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18894 if (!SWIG_IsOK(res1)) {
18895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18896 }
18897 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18898 {
18899 PyThreadState* __tstate = wxPyBeginAllowThreads();
18900 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18901 wxPyEndAllowThreads(__tstate);
18902 if (PyErr_Occurred()) SWIG_fail;
18903 }
18904 resultobj = SWIG_From_int(static_cast< int >(result));
18905 return resultobj;
18906 fail:
18907 return NULL;
18908 }
18909
18910
18911 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18912 PyObject *resultobj = 0;
18913 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18914 wxString *arg2 = 0 ;
18915 void *argp1 = 0 ;
18916 int res1 = 0 ;
18917 bool temp2 = false ;
18918 PyObject * obj0 = 0 ;
18919 PyObject * obj1 = 0 ;
18920 char * kwnames[] = {
18921 (char *) "self",(char *) "s", NULL
18922 };
18923
18924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18926 if (!SWIG_IsOK(res1)) {
18927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18928 }
18929 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18930 {
18931 arg2 = wxString_in_helper(obj1);
18932 if (arg2 == NULL) SWIG_fail;
18933 temp2 = true;
18934 }
18935 {
18936 PyThreadState* __tstate = wxPyBeginAllowThreads();
18937 (arg1)->SetString((wxString const &)*arg2);
18938 wxPyEndAllowThreads(__tstate);
18939 if (PyErr_Occurred()) SWIG_fail;
18940 }
18941 resultobj = SWIG_Py_Void();
18942 {
18943 if (temp2)
18944 delete arg2;
18945 }
18946 return resultobj;
18947 fail:
18948 {
18949 if (temp2)
18950 delete arg2;
18951 }
18952 return NULL;
18953 }
18954
18955
18956 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18957 PyObject *resultobj = 0;
18958 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18959 wxString result;
18960 void *argp1 = 0 ;
18961 int res1 = 0 ;
18962 PyObject *swig_obj[1] ;
18963
18964 if (!args) SWIG_fail;
18965 swig_obj[0] = args;
18966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18967 if (!SWIG_IsOK(res1)) {
18968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18969 }
18970 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18971 {
18972 PyThreadState* __tstate = wxPyBeginAllowThreads();
18973 result = ((wxCommandEvent const *)arg1)->GetString();
18974 wxPyEndAllowThreads(__tstate);
18975 if (PyErr_Occurred()) SWIG_fail;
18976 }
18977 {
18978 #if wxUSE_UNICODE
18979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18980 #else
18981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18982 #endif
18983 }
18984 return resultobj;
18985 fail:
18986 return NULL;
18987 }
18988
18989
18990 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18991 PyObject *resultobj = 0;
18992 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18993 bool result;
18994 void *argp1 = 0 ;
18995 int res1 = 0 ;
18996 PyObject *swig_obj[1] ;
18997
18998 if (!args) SWIG_fail;
18999 swig_obj[0] = args;
19000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19001 if (!SWIG_IsOK(res1)) {
19002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19003 }
19004 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19005 {
19006 PyThreadState* __tstate = wxPyBeginAllowThreads();
19007 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19008 wxPyEndAllowThreads(__tstate);
19009 if (PyErr_Occurred()) SWIG_fail;
19010 }
19011 {
19012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19013 }
19014 return resultobj;
19015 fail:
19016 return NULL;
19017 }
19018
19019
19020 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19021 PyObject *resultobj = 0;
19022 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19023 bool result;
19024 void *argp1 = 0 ;
19025 int res1 = 0 ;
19026 PyObject *swig_obj[1] ;
19027
19028 if (!args) SWIG_fail;
19029 swig_obj[0] = args;
19030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19031 if (!SWIG_IsOK(res1)) {
19032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19033 }
19034 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19035 {
19036 PyThreadState* __tstate = wxPyBeginAllowThreads();
19037 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19038 wxPyEndAllowThreads(__tstate);
19039 if (PyErr_Occurred()) SWIG_fail;
19040 }
19041 {
19042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19043 }
19044 return resultobj;
19045 fail:
19046 return NULL;
19047 }
19048
19049
19050 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19051 PyObject *resultobj = 0;
19052 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19053 long arg2 ;
19054 void *argp1 = 0 ;
19055 int res1 = 0 ;
19056 long val2 ;
19057 int ecode2 = 0 ;
19058 PyObject * obj0 = 0 ;
19059 PyObject * obj1 = 0 ;
19060 char * kwnames[] = {
19061 (char *) "self",(char *) "extraLong", NULL
19062 };
19063
19064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19066 if (!SWIG_IsOK(res1)) {
19067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19068 }
19069 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19070 ecode2 = SWIG_AsVal_long(obj1, &val2);
19071 if (!SWIG_IsOK(ecode2)) {
19072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19073 }
19074 arg2 = static_cast< long >(val2);
19075 {
19076 PyThreadState* __tstate = wxPyBeginAllowThreads();
19077 (arg1)->SetExtraLong(arg2);
19078 wxPyEndAllowThreads(__tstate);
19079 if (PyErr_Occurred()) SWIG_fail;
19080 }
19081 resultobj = SWIG_Py_Void();
19082 return resultobj;
19083 fail:
19084 return NULL;
19085 }
19086
19087
19088 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19089 PyObject *resultobj = 0;
19090 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19091 long result;
19092 void *argp1 = 0 ;
19093 int res1 = 0 ;
19094 PyObject *swig_obj[1] ;
19095
19096 if (!args) SWIG_fail;
19097 swig_obj[0] = args;
19098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19099 if (!SWIG_IsOK(res1)) {
19100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19101 }
19102 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19103 {
19104 PyThreadState* __tstate = wxPyBeginAllowThreads();
19105 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19106 wxPyEndAllowThreads(__tstate);
19107 if (PyErr_Occurred()) SWIG_fail;
19108 }
19109 resultobj = SWIG_From_long(static_cast< long >(result));
19110 return resultobj;
19111 fail:
19112 return NULL;
19113 }
19114
19115
19116 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19117 PyObject *resultobj = 0;
19118 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19119 int arg2 ;
19120 void *argp1 = 0 ;
19121 int res1 = 0 ;
19122 int val2 ;
19123 int ecode2 = 0 ;
19124 PyObject * obj0 = 0 ;
19125 PyObject * obj1 = 0 ;
19126 char * kwnames[] = {
19127 (char *) "self",(char *) "i", NULL
19128 };
19129
19130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19132 if (!SWIG_IsOK(res1)) {
19133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19134 }
19135 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19136 ecode2 = SWIG_AsVal_int(obj1, &val2);
19137 if (!SWIG_IsOK(ecode2)) {
19138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19139 }
19140 arg2 = static_cast< int >(val2);
19141 {
19142 PyThreadState* __tstate = wxPyBeginAllowThreads();
19143 (arg1)->SetInt(arg2);
19144 wxPyEndAllowThreads(__tstate);
19145 if (PyErr_Occurred()) SWIG_fail;
19146 }
19147 resultobj = SWIG_Py_Void();
19148 return resultobj;
19149 fail:
19150 return NULL;
19151 }
19152
19153
19154 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19155 PyObject *resultobj = 0;
19156 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19157 int result;
19158 void *argp1 = 0 ;
19159 int res1 = 0 ;
19160 PyObject *swig_obj[1] ;
19161
19162 if (!args) SWIG_fail;
19163 swig_obj[0] = args;
19164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19165 if (!SWIG_IsOK(res1)) {
19166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19167 }
19168 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19169 {
19170 PyThreadState* __tstate = wxPyBeginAllowThreads();
19171 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19172 wxPyEndAllowThreads(__tstate);
19173 if (PyErr_Occurred()) SWIG_fail;
19174 }
19175 resultobj = SWIG_From_int(static_cast< int >(result));
19176 return resultobj;
19177 fail:
19178 return NULL;
19179 }
19180
19181
19182 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19183 PyObject *resultobj = 0;
19184 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19185 PyObject *result = 0 ;
19186 void *argp1 = 0 ;
19187 int res1 = 0 ;
19188 PyObject *swig_obj[1] ;
19189
19190 if (!args) SWIG_fail;
19191 swig_obj[0] = args;
19192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19193 if (!SWIG_IsOK(res1)) {
19194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19195 }
19196 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19197 {
19198 PyThreadState* __tstate = wxPyBeginAllowThreads();
19199 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19200 wxPyEndAllowThreads(__tstate);
19201 if (PyErr_Occurred()) SWIG_fail;
19202 }
19203 resultobj = result;
19204 return resultobj;
19205 fail:
19206 return NULL;
19207 }
19208
19209
19210 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19211 PyObject *resultobj = 0;
19212 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19213 PyObject *arg2 = (PyObject *) 0 ;
19214 void *argp1 = 0 ;
19215 int res1 = 0 ;
19216 PyObject * obj0 = 0 ;
19217 PyObject * obj1 = 0 ;
19218 char * kwnames[] = {
19219 (char *) "self",(char *) "clientData", NULL
19220 };
19221
19222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19224 if (!SWIG_IsOK(res1)) {
19225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19226 }
19227 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19228 arg2 = obj1;
19229 {
19230 PyThreadState* __tstate = wxPyBeginAllowThreads();
19231 wxCommandEvent_SetClientData(arg1,arg2);
19232 wxPyEndAllowThreads(__tstate);
19233 if (PyErr_Occurred()) SWIG_fail;
19234 }
19235 resultobj = SWIG_Py_Void();
19236 return resultobj;
19237 fail:
19238 return NULL;
19239 }
19240
19241
19242 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19243 PyObject *resultobj = 0;
19244 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19245 wxEvent *result = 0 ;
19246 void *argp1 = 0 ;
19247 int res1 = 0 ;
19248 PyObject *swig_obj[1] ;
19249
19250 if (!args) SWIG_fail;
19251 swig_obj[0] = args;
19252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19253 if (!SWIG_IsOK(res1)) {
19254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19255 }
19256 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19257 {
19258 PyThreadState* __tstate = wxPyBeginAllowThreads();
19259 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19260 wxPyEndAllowThreads(__tstate);
19261 if (PyErr_Occurred()) SWIG_fail;
19262 }
19263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19264 return resultobj;
19265 fail:
19266 return NULL;
19267 }
19268
19269
19270 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19271 PyObject *obj;
19272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19273 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19274 return SWIG_Py_Void();
19275 }
19276
19277 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19278 return SWIG_Python_InitShadowInstance(args);
19279 }
19280
19281 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19282 PyObject *resultobj = 0;
19283 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19284 int arg2 = (int) 0 ;
19285 wxNotifyEvent *result = 0 ;
19286 int val1 ;
19287 int ecode1 = 0 ;
19288 int val2 ;
19289 int ecode2 = 0 ;
19290 PyObject * obj0 = 0 ;
19291 PyObject * obj1 = 0 ;
19292 char * kwnames[] = {
19293 (char *) "commandType",(char *) "winid", NULL
19294 };
19295
19296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19297 if (obj0) {
19298 ecode1 = SWIG_AsVal_int(obj0, &val1);
19299 if (!SWIG_IsOK(ecode1)) {
19300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19301 }
19302 arg1 = static_cast< wxEventType >(val1);
19303 }
19304 if (obj1) {
19305 ecode2 = SWIG_AsVal_int(obj1, &val2);
19306 if (!SWIG_IsOK(ecode2)) {
19307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19308 }
19309 arg2 = static_cast< int >(val2);
19310 }
19311 {
19312 PyThreadState* __tstate = wxPyBeginAllowThreads();
19313 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19314 wxPyEndAllowThreads(__tstate);
19315 if (PyErr_Occurred()) SWIG_fail;
19316 }
19317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19318 return resultobj;
19319 fail:
19320 return NULL;
19321 }
19322
19323
19324 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19325 PyObject *resultobj = 0;
19326 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19327 void *argp1 = 0 ;
19328 int res1 = 0 ;
19329 PyObject *swig_obj[1] ;
19330
19331 if (!args) SWIG_fail;
19332 swig_obj[0] = args;
19333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19334 if (!SWIG_IsOK(res1)) {
19335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19336 }
19337 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19338 {
19339 PyThreadState* __tstate = wxPyBeginAllowThreads();
19340 (arg1)->Veto();
19341 wxPyEndAllowThreads(__tstate);
19342 if (PyErr_Occurred()) SWIG_fail;
19343 }
19344 resultobj = SWIG_Py_Void();
19345 return resultobj;
19346 fail:
19347 return NULL;
19348 }
19349
19350
19351 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19352 PyObject *resultobj = 0;
19353 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19354 void *argp1 = 0 ;
19355 int res1 = 0 ;
19356 PyObject *swig_obj[1] ;
19357
19358 if (!args) SWIG_fail;
19359 swig_obj[0] = args;
19360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19361 if (!SWIG_IsOK(res1)) {
19362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19363 }
19364 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19365 {
19366 PyThreadState* __tstate = wxPyBeginAllowThreads();
19367 (arg1)->Allow();
19368 wxPyEndAllowThreads(__tstate);
19369 if (PyErr_Occurred()) SWIG_fail;
19370 }
19371 resultobj = SWIG_Py_Void();
19372 return resultobj;
19373 fail:
19374 return NULL;
19375 }
19376
19377
19378 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19379 PyObject *resultobj = 0;
19380 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19381 bool result;
19382 void *argp1 = 0 ;
19383 int res1 = 0 ;
19384 PyObject *swig_obj[1] ;
19385
19386 if (!args) SWIG_fail;
19387 swig_obj[0] = args;
19388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19389 if (!SWIG_IsOK(res1)) {
19390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19391 }
19392 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19393 {
19394 PyThreadState* __tstate = wxPyBeginAllowThreads();
19395 result = (bool)(arg1)->IsAllowed();
19396 wxPyEndAllowThreads(__tstate);
19397 if (PyErr_Occurred()) SWIG_fail;
19398 }
19399 {
19400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19401 }
19402 return resultobj;
19403 fail:
19404 return NULL;
19405 }
19406
19407
19408 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19409 PyObject *obj;
19410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19411 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19412 return SWIG_Py_Void();
19413 }
19414
19415 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19416 return SWIG_Python_InitShadowInstance(args);
19417 }
19418
19419 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19420 PyObject *resultobj = 0;
19421 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19422 int arg2 = (int) 0 ;
19423 int arg3 = (int) 0 ;
19424 int arg4 = (int) 0 ;
19425 wxScrollEvent *result = 0 ;
19426 int val1 ;
19427 int ecode1 = 0 ;
19428 int val2 ;
19429 int ecode2 = 0 ;
19430 int val3 ;
19431 int ecode3 = 0 ;
19432 int val4 ;
19433 int ecode4 = 0 ;
19434 PyObject * obj0 = 0 ;
19435 PyObject * obj1 = 0 ;
19436 PyObject * obj2 = 0 ;
19437 PyObject * obj3 = 0 ;
19438 char * kwnames[] = {
19439 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19440 };
19441
19442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19443 if (obj0) {
19444 ecode1 = SWIG_AsVal_int(obj0, &val1);
19445 if (!SWIG_IsOK(ecode1)) {
19446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19447 }
19448 arg1 = static_cast< wxEventType >(val1);
19449 }
19450 if (obj1) {
19451 ecode2 = SWIG_AsVal_int(obj1, &val2);
19452 if (!SWIG_IsOK(ecode2)) {
19453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19454 }
19455 arg2 = static_cast< int >(val2);
19456 }
19457 if (obj2) {
19458 ecode3 = SWIG_AsVal_int(obj2, &val3);
19459 if (!SWIG_IsOK(ecode3)) {
19460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19461 }
19462 arg3 = static_cast< int >(val3);
19463 }
19464 if (obj3) {
19465 ecode4 = SWIG_AsVal_int(obj3, &val4);
19466 if (!SWIG_IsOK(ecode4)) {
19467 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19468 }
19469 arg4 = static_cast< int >(val4);
19470 }
19471 {
19472 PyThreadState* __tstate = wxPyBeginAllowThreads();
19473 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19474 wxPyEndAllowThreads(__tstate);
19475 if (PyErr_Occurred()) SWIG_fail;
19476 }
19477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19478 return resultobj;
19479 fail:
19480 return NULL;
19481 }
19482
19483
19484 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19485 PyObject *resultobj = 0;
19486 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19487 int result;
19488 void *argp1 = 0 ;
19489 int res1 = 0 ;
19490 PyObject *swig_obj[1] ;
19491
19492 if (!args) SWIG_fail;
19493 swig_obj[0] = args;
19494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19495 if (!SWIG_IsOK(res1)) {
19496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19497 }
19498 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19499 {
19500 PyThreadState* __tstate = wxPyBeginAllowThreads();
19501 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19502 wxPyEndAllowThreads(__tstate);
19503 if (PyErr_Occurred()) SWIG_fail;
19504 }
19505 resultobj = SWIG_From_int(static_cast< int >(result));
19506 return resultobj;
19507 fail:
19508 return NULL;
19509 }
19510
19511
19512 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19513 PyObject *resultobj = 0;
19514 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19515 int result;
19516 void *argp1 = 0 ;
19517 int res1 = 0 ;
19518 PyObject *swig_obj[1] ;
19519
19520 if (!args) SWIG_fail;
19521 swig_obj[0] = args;
19522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19523 if (!SWIG_IsOK(res1)) {
19524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19525 }
19526 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19527 {
19528 PyThreadState* __tstate = wxPyBeginAllowThreads();
19529 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19530 wxPyEndAllowThreads(__tstate);
19531 if (PyErr_Occurred()) SWIG_fail;
19532 }
19533 resultobj = SWIG_From_int(static_cast< int >(result));
19534 return resultobj;
19535 fail:
19536 return NULL;
19537 }
19538
19539
19540 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19541 PyObject *resultobj = 0;
19542 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19543 int arg2 ;
19544 void *argp1 = 0 ;
19545 int res1 = 0 ;
19546 int val2 ;
19547 int ecode2 = 0 ;
19548 PyObject * obj0 = 0 ;
19549 PyObject * obj1 = 0 ;
19550 char * kwnames[] = {
19551 (char *) "self",(char *) "orient", NULL
19552 };
19553
19554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19556 if (!SWIG_IsOK(res1)) {
19557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19558 }
19559 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19560 ecode2 = SWIG_AsVal_int(obj1, &val2);
19561 if (!SWIG_IsOK(ecode2)) {
19562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19563 }
19564 arg2 = static_cast< int >(val2);
19565 {
19566 PyThreadState* __tstate = wxPyBeginAllowThreads();
19567 (arg1)->SetOrientation(arg2);
19568 wxPyEndAllowThreads(__tstate);
19569 if (PyErr_Occurred()) SWIG_fail;
19570 }
19571 resultobj = SWIG_Py_Void();
19572 return resultobj;
19573 fail:
19574 return NULL;
19575 }
19576
19577
19578 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19579 PyObject *resultobj = 0;
19580 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19581 int arg2 ;
19582 void *argp1 = 0 ;
19583 int res1 = 0 ;
19584 int val2 ;
19585 int ecode2 = 0 ;
19586 PyObject * obj0 = 0 ;
19587 PyObject * obj1 = 0 ;
19588 char * kwnames[] = {
19589 (char *) "self",(char *) "pos", NULL
19590 };
19591
19592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19594 if (!SWIG_IsOK(res1)) {
19595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19596 }
19597 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19598 ecode2 = SWIG_AsVal_int(obj1, &val2);
19599 if (!SWIG_IsOK(ecode2)) {
19600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19601 }
19602 arg2 = static_cast< int >(val2);
19603 {
19604 PyThreadState* __tstate = wxPyBeginAllowThreads();
19605 (arg1)->SetPosition(arg2);
19606 wxPyEndAllowThreads(__tstate);
19607 if (PyErr_Occurred()) SWIG_fail;
19608 }
19609 resultobj = SWIG_Py_Void();
19610 return resultobj;
19611 fail:
19612 return NULL;
19613 }
19614
19615
19616 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19617 PyObject *obj;
19618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19619 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19620 return SWIG_Py_Void();
19621 }
19622
19623 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19624 return SWIG_Python_InitShadowInstance(args);
19625 }
19626
19627 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19628 PyObject *resultobj = 0;
19629 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19630 int arg2 = (int) 0 ;
19631 int arg3 = (int) 0 ;
19632 wxScrollWinEvent *result = 0 ;
19633 int val1 ;
19634 int ecode1 = 0 ;
19635 int val2 ;
19636 int ecode2 = 0 ;
19637 int val3 ;
19638 int ecode3 = 0 ;
19639 PyObject * obj0 = 0 ;
19640 PyObject * obj1 = 0 ;
19641 PyObject * obj2 = 0 ;
19642 char * kwnames[] = {
19643 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19644 };
19645
19646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19647 if (obj0) {
19648 ecode1 = SWIG_AsVal_int(obj0, &val1);
19649 if (!SWIG_IsOK(ecode1)) {
19650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19651 }
19652 arg1 = static_cast< wxEventType >(val1);
19653 }
19654 if (obj1) {
19655 ecode2 = SWIG_AsVal_int(obj1, &val2);
19656 if (!SWIG_IsOK(ecode2)) {
19657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19658 }
19659 arg2 = static_cast< int >(val2);
19660 }
19661 if (obj2) {
19662 ecode3 = SWIG_AsVal_int(obj2, &val3);
19663 if (!SWIG_IsOK(ecode3)) {
19664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19665 }
19666 arg3 = static_cast< int >(val3);
19667 }
19668 {
19669 PyThreadState* __tstate = wxPyBeginAllowThreads();
19670 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19671 wxPyEndAllowThreads(__tstate);
19672 if (PyErr_Occurred()) SWIG_fail;
19673 }
19674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19675 return resultobj;
19676 fail:
19677 return NULL;
19678 }
19679
19680
19681 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19682 PyObject *resultobj = 0;
19683 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19684 int result;
19685 void *argp1 = 0 ;
19686 int res1 = 0 ;
19687 PyObject *swig_obj[1] ;
19688
19689 if (!args) SWIG_fail;
19690 swig_obj[0] = args;
19691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19692 if (!SWIG_IsOK(res1)) {
19693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19694 }
19695 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19696 {
19697 PyThreadState* __tstate = wxPyBeginAllowThreads();
19698 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19699 wxPyEndAllowThreads(__tstate);
19700 if (PyErr_Occurred()) SWIG_fail;
19701 }
19702 resultobj = SWIG_From_int(static_cast< int >(result));
19703 return resultobj;
19704 fail:
19705 return NULL;
19706 }
19707
19708
19709 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19710 PyObject *resultobj = 0;
19711 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19712 int result;
19713 void *argp1 = 0 ;
19714 int res1 = 0 ;
19715 PyObject *swig_obj[1] ;
19716
19717 if (!args) SWIG_fail;
19718 swig_obj[0] = args;
19719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19720 if (!SWIG_IsOK(res1)) {
19721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19722 }
19723 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19724 {
19725 PyThreadState* __tstate = wxPyBeginAllowThreads();
19726 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19727 wxPyEndAllowThreads(__tstate);
19728 if (PyErr_Occurred()) SWIG_fail;
19729 }
19730 resultobj = SWIG_From_int(static_cast< int >(result));
19731 return resultobj;
19732 fail:
19733 return NULL;
19734 }
19735
19736
19737 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19738 PyObject *resultobj = 0;
19739 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19740 int arg2 ;
19741 void *argp1 = 0 ;
19742 int res1 = 0 ;
19743 int val2 ;
19744 int ecode2 = 0 ;
19745 PyObject * obj0 = 0 ;
19746 PyObject * obj1 = 0 ;
19747 char * kwnames[] = {
19748 (char *) "self",(char *) "orient", NULL
19749 };
19750
19751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19753 if (!SWIG_IsOK(res1)) {
19754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19755 }
19756 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19757 ecode2 = SWIG_AsVal_int(obj1, &val2);
19758 if (!SWIG_IsOK(ecode2)) {
19759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19760 }
19761 arg2 = static_cast< int >(val2);
19762 {
19763 PyThreadState* __tstate = wxPyBeginAllowThreads();
19764 (arg1)->SetOrientation(arg2);
19765 wxPyEndAllowThreads(__tstate);
19766 if (PyErr_Occurred()) SWIG_fail;
19767 }
19768 resultobj = SWIG_Py_Void();
19769 return resultobj;
19770 fail:
19771 return NULL;
19772 }
19773
19774
19775 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19776 PyObject *resultobj = 0;
19777 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19778 int arg2 ;
19779 void *argp1 = 0 ;
19780 int res1 = 0 ;
19781 int val2 ;
19782 int ecode2 = 0 ;
19783 PyObject * obj0 = 0 ;
19784 PyObject * obj1 = 0 ;
19785 char * kwnames[] = {
19786 (char *) "self",(char *) "pos", NULL
19787 };
19788
19789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19791 if (!SWIG_IsOK(res1)) {
19792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19793 }
19794 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19795 ecode2 = SWIG_AsVal_int(obj1, &val2);
19796 if (!SWIG_IsOK(ecode2)) {
19797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19798 }
19799 arg2 = static_cast< int >(val2);
19800 {
19801 PyThreadState* __tstate = wxPyBeginAllowThreads();
19802 (arg1)->SetPosition(arg2);
19803 wxPyEndAllowThreads(__tstate);
19804 if (PyErr_Occurred()) SWIG_fail;
19805 }
19806 resultobj = SWIG_Py_Void();
19807 return resultobj;
19808 fail:
19809 return NULL;
19810 }
19811
19812
19813 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19814 PyObject *obj;
19815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19816 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19817 return SWIG_Py_Void();
19818 }
19819
19820 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19821 return SWIG_Python_InitShadowInstance(args);
19822 }
19823
19824 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19825 PyObject *resultobj = 0;
19826 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19827 wxMouseEvent *result = 0 ;
19828 int val1 ;
19829 int ecode1 = 0 ;
19830 PyObject * obj0 = 0 ;
19831 char * kwnames[] = {
19832 (char *) "mouseType", NULL
19833 };
19834
19835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19836 if (obj0) {
19837 ecode1 = SWIG_AsVal_int(obj0, &val1);
19838 if (!SWIG_IsOK(ecode1)) {
19839 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19840 }
19841 arg1 = static_cast< wxEventType >(val1);
19842 }
19843 {
19844 PyThreadState* __tstate = wxPyBeginAllowThreads();
19845 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19846 wxPyEndAllowThreads(__tstate);
19847 if (PyErr_Occurred()) SWIG_fail;
19848 }
19849 {
19850 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19851 }
19852 return resultobj;
19853 fail:
19854 return NULL;
19855 }
19856
19857
19858 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19859 PyObject *resultobj = 0;
19860 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19861 bool result;
19862 void *argp1 = 0 ;
19863 int res1 = 0 ;
19864 PyObject *swig_obj[1] ;
19865
19866 if (!args) SWIG_fail;
19867 swig_obj[0] = args;
19868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19869 if (!SWIG_IsOK(res1)) {
19870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19871 }
19872 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19873 {
19874 PyThreadState* __tstate = wxPyBeginAllowThreads();
19875 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19876 wxPyEndAllowThreads(__tstate);
19877 if (PyErr_Occurred()) SWIG_fail;
19878 }
19879 {
19880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19881 }
19882 return resultobj;
19883 fail:
19884 return NULL;
19885 }
19886
19887
19888 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19889 PyObject *resultobj = 0;
19890 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19891 int arg2 = (int) wxMOUSE_BTN_ANY ;
19892 bool result;
19893 void *argp1 = 0 ;
19894 int res1 = 0 ;
19895 int val2 ;
19896 int ecode2 = 0 ;
19897 PyObject * obj0 = 0 ;
19898 PyObject * obj1 = 0 ;
19899 char * kwnames[] = {
19900 (char *) "self",(char *) "but", NULL
19901 };
19902
19903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19905 if (!SWIG_IsOK(res1)) {
19906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19907 }
19908 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19909 if (obj1) {
19910 ecode2 = SWIG_AsVal_int(obj1, &val2);
19911 if (!SWIG_IsOK(ecode2)) {
19912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19913 }
19914 arg2 = static_cast< int >(val2);
19915 }
19916 {
19917 PyThreadState* __tstate = wxPyBeginAllowThreads();
19918 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19919 wxPyEndAllowThreads(__tstate);
19920 if (PyErr_Occurred()) SWIG_fail;
19921 }
19922 {
19923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19924 }
19925 return resultobj;
19926 fail:
19927 return NULL;
19928 }
19929
19930
19931 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19932 PyObject *resultobj = 0;
19933 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19934 int arg2 = (int) wxMOUSE_BTN_ANY ;
19935 bool result;
19936 void *argp1 = 0 ;
19937 int res1 = 0 ;
19938 int val2 ;
19939 int ecode2 = 0 ;
19940 PyObject * obj0 = 0 ;
19941 PyObject * obj1 = 0 ;
19942 char * kwnames[] = {
19943 (char *) "self",(char *) "but", NULL
19944 };
19945
19946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19948 if (!SWIG_IsOK(res1)) {
19949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19950 }
19951 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19952 if (obj1) {
19953 ecode2 = SWIG_AsVal_int(obj1, &val2);
19954 if (!SWIG_IsOK(ecode2)) {
19955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19956 }
19957 arg2 = static_cast< int >(val2);
19958 }
19959 {
19960 PyThreadState* __tstate = wxPyBeginAllowThreads();
19961 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19962 wxPyEndAllowThreads(__tstate);
19963 if (PyErr_Occurred()) SWIG_fail;
19964 }
19965 {
19966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19967 }
19968 return resultobj;
19969 fail:
19970 return NULL;
19971 }
19972
19973
19974 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19975 PyObject *resultobj = 0;
19976 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19977 int arg2 = (int) wxMOUSE_BTN_ANY ;
19978 bool result;
19979 void *argp1 = 0 ;
19980 int res1 = 0 ;
19981 int val2 ;
19982 int ecode2 = 0 ;
19983 PyObject * obj0 = 0 ;
19984 PyObject * obj1 = 0 ;
19985 char * kwnames[] = {
19986 (char *) "self",(char *) "but", NULL
19987 };
19988
19989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19991 if (!SWIG_IsOK(res1)) {
19992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19993 }
19994 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19995 if (obj1) {
19996 ecode2 = SWIG_AsVal_int(obj1, &val2);
19997 if (!SWIG_IsOK(ecode2)) {
19998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19999 }
20000 arg2 = static_cast< int >(val2);
20001 }
20002 {
20003 PyThreadState* __tstate = wxPyBeginAllowThreads();
20004 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20005 wxPyEndAllowThreads(__tstate);
20006 if (PyErr_Occurred()) SWIG_fail;
20007 }
20008 {
20009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20010 }
20011 return resultobj;
20012 fail:
20013 return NULL;
20014 }
20015
20016
20017 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20018 PyObject *resultobj = 0;
20019 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20020 int arg2 ;
20021 bool result;
20022 void *argp1 = 0 ;
20023 int res1 = 0 ;
20024 int val2 ;
20025 int ecode2 = 0 ;
20026 PyObject * obj0 = 0 ;
20027 PyObject * obj1 = 0 ;
20028 char * kwnames[] = {
20029 (char *) "self",(char *) "button", NULL
20030 };
20031
20032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20034 if (!SWIG_IsOK(res1)) {
20035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20036 }
20037 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20038 ecode2 = SWIG_AsVal_int(obj1, &val2);
20039 if (!SWIG_IsOK(ecode2)) {
20040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20041 }
20042 arg2 = static_cast< int >(val2);
20043 {
20044 PyThreadState* __tstate = wxPyBeginAllowThreads();
20045 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20046 wxPyEndAllowThreads(__tstate);
20047 if (PyErr_Occurred()) SWIG_fail;
20048 }
20049 {
20050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20051 }
20052 return resultobj;
20053 fail:
20054 return NULL;
20055 }
20056
20057
20058 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20059 PyObject *resultobj = 0;
20060 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20061 int arg2 ;
20062 bool result;
20063 void *argp1 = 0 ;
20064 int res1 = 0 ;
20065 int val2 ;
20066 int ecode2 = 0 ;
20067 PyObject * obj0 = 0 ;
20068 PyObject * obj1 = 0 ;
20069 char * kwnames[] = {
20070 (char *) "self",(char *) "but", NULL
20071 };
20072
20073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20075 if (!SWIG_IsOK(res1)) {
20076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20077 }
20078 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20079 ecode2 = SWIG_AsVal_int(obj1, &val2);
20080 if (!SWIG_IsOK(ecode2)) {
20081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20082 }
20083 arg2 = static_cast< int >(val2);
20084 {
20085 PyThreadState* __tstate = wxPyBeginAllowThreads();
20086 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20087 wxPyEndAllowThreads(__tstate);
20088 if (PyErr_Occurred()) SWIG_fail;
20089 }
20090 {
20091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20092 }
20093 return resultobj;
20094 fail:
20095 return NULL;
20096 }
20097
20098
20099 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20100 PyObject *resultobj = 0;
20101 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20102 int result;
20103 void *argp1 = 0 ;
20104 int res1 = 0 ;
20105 PyObject *swig_obj[1] ;
20106
20107 if (!args) SWIG_fail;
20108 swig_obj[0] = args;
20109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20110 if (!SWIG_IsOK(res1)) {
20111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20112 }
20113 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20114 {
20115 PyThreadState* __tstate = wxPyBeginAllowThreads();
20116 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20117 wxPyEndAllowThreads(__tstate);
20118 if (PyErr_Occurred()) SWIG_fail;
20119 }
20120 resultobj = SWIG_From_int(static_cast< int >(result));
20121 return resultobj;
20122 fail:
20123 return NULL;
20124 }
20125
20126
20127 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20128 PyObject *resultobj = 0;
20129 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20130 bool result;
20131 void *argp1 = 0 ;
20132 int res1 = 0 ;
20133 PyObject *swig_obj[1] ;
20134
20135 if (!args) SWIG_fail;
20136 swig_obj[0] = args;
20137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20138 if (!SWIG_IsOK(res1)) {
20139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20140 }
20141 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20142 {
20143 PyThreadState* __tstate = wxPyBeginAllowThreads();
20144 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20145 wxPyEndAllowThreads(__tstate);
20146 if (PyErr_Occurred()) SWIG_fail;
20147 }
20148 {
20149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20150 }
20151 return resultobj;
20152 fail:
20153 return NULL;
20154 }
20155
20156
20157 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20158 PyObject *resultobj = 0;
20159 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20160 bool result;
20161 void *argp1 = 0 ;
20162 int res1 = 0 ;
20163 PyObject *swig_obj[1] ;
20164
20165 if (!args) SWIG_fail;
20166 swig_obj[0] = args;
20167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20168 if (!SWIG_IsOK(res1)) {
20169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20170 }
20171 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20172 {
20173 PyThreadState* __tstate = wxPyBeginAllowThreads();
20174 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20175 wxPyEndAllowThreads(__tstate);
20176 if (PyErr_Occurred()) SWIG_fail;
20177 }
20178 {
20179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20180 }
20181 return resultobj;
20182 fail:
20183 return NULL;
20184 }
20185
20186
20187 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20188 PyObject *resultobj = 0;
20189 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20190 bool result;
20191 void *argp1 = 0 ;
20192 int res1 = 0 ;
20193 PyObject *swig_obj[1] ;
20194
20195 if (!args) SWIG_fail;
20196 swig_obj[0] = args;
20197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20198 if (!SWIG_IsOK(res1)) {
20199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20200 }
20201 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20202 {
20203 PyThreadState* __tstate = wxPyBeginAllowThreads();
20204 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20205 wxPyEndAllowThreads(__tstate);
20206 if (PyErr_Occurred()) SWIG_fail;
20207 }
20208 {
20209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20210 }
20211 return resultobj;
20212 fail:
20213 return NULL;
20214 }
20215
20216
20217 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20218 PyObject *resultobj = 0;
20219 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20220 bool result;
20221 void *argp1 = 0 ;
20222 int res1 = 0 ;
20223 PyObject *swig_obj[1] ;
20224
20225 if (!args) SWIG_fail;
20226 swig_obj[0] = args;
20227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20228 if (!SWIG_IsOK(res1)) {
20229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20230 }
20231 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20232 {
20233 PyThreadState* __tstate = wxPyBeginAllowThreads();
20234 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20235 wxPyEndAllowThreads(__tstate);
20236 if (PyErr_Occurred()) SWIG_fail;
20237 }
20238 {
20239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20240 }
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20248 PyObject *resultobj = 0;
20249 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20250 bool result;
20251 void *argp1 = 0 ;
20252 int res1 = 0 ;
20253 PyObject *swig_obj[1] ;
20254
20255 if (!args) SWIG_fail;
20256 swig_obj[0] = args;
20257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20258 if (!SWIG_IsOK(res1)) {
20259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20260 }
20261 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20262 {
20263 PyThreadState* __tstate = wxPyBeginAllowThreads();
20264 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 {
20269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20270 }
20271 return resultobj;
20272 fail:
20273 return NULL;
20274 }
20275
20276
20277 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20278 PyObject *resultobj = 0;
20279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20280 bool result;
20281 void *argp1 = 0 ;
20282 int res1 = 0 ;
20283 PyObject *swig_obj[1] ;
20284
20285 if (!args) SWIG_fail;
20286 swig_obj[0] = args;
20287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20288 if (!SWIG_IsOK(res1)) {
20289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20290 }
20291 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20292 {
20293 PyThreadState* __tstate = wxPyBeginAllowThreads();
20294 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 {
20299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20300 }
20301 return resultobj;
20302 fail:
20303 return NULL;
20304 }
20305
20306
20307 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20308 PyObject *resultobj = 0;
20309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20310 bool result;
20311 void *argp1 = 0 ;
20312 int res1 = 0 ;
20313 PyObject *swig_obj[1] ;
20314
20315 if (!args) SWIG_fail;
20316 swig_obj[0] = args;
20317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20318 if (!SWIG_IsOK(res1)) {
20319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20320 }
20321 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20322 {
20323 PyThreadState* __tstate = wxPyBeginAllowThreads();
20324 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20325 wxPyEndAllowThreads(__tstate);
20326 if (PyErr_Occurred()) SWIG_fail;
20327 }
20328 {
20329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20330 }
20331 return resultobj;
20332 fail:
20333 return NULL;
20334 }
20335
20336
20337 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20338 PyObject *resultobj = 0;
20339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20340 bool result;
20341 void *argp1 = 0 ;
20342 int res1 = 0 ;
20343 PyObject *swig_obj[1] ;
20344
20345 if (!args) SWIG_fail;
20346 swig_obj[0] = args;
20347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20348 if (!SWIG_IsOK(res1)) {
20349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20350 }
20351 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20352 {
20353 PyThreadState* __tstate = wxPyBeginAllowThreads();
20354 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20355 wxPyEndAllowThreads(__tstate);
20356 if (PyErr_Occurred()) SWIG_fail;
20357 }
20358 {
20359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20360 }
20361 return resultobj;
20362 fail:
20363 return NULL;
20364 }
20365
20366
20367 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20368 PyObject *resultobj = 0;
20369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20370 bool result;
20371 void *argp1 = 0 ;
20372 int res1 = 0 ;
20373 PyObject *swig_obj[1] ;
20374
20375 if (!args) SWIG_fail;
20376 swig_obj[0] = args;
20377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20378 if (!SWIG_IsOK(res1)) {
20379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20380 }
20381 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20382 {
20383 PyThreadState* __tstate = wxPyBeginAllowThreads();
20384 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20385 wxPyEndAllowThreads(__tstate);
20386 if (PyErr_Occurred()) SWIG_fail;
20387 }
20388 {
20389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20390 }
20391 return resultobj;
20392 fail:
20393 return NULL;
20394 }
20395
20396
20397 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20398 PyObject *resultobj = 0;
20399 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20400 bool result;
20401 void *argp1 = 0 ;
20402 int res1 = 0 ;
20403 PyObject *swig_obj[1] ;
20404
20405 if (!args) SWIG_fail;
20406 swig_obj[0] = args;
20407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20408 if (!SWIG_IsOK(res1)) {
20409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20410 }
20411 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20412 {
20413 PyThreadState* __tstate = wxPyBeginAllowThreads();
20414 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20415 wxPyEndAllowThreads(__tstate);
20416 if (PyErr_Occurred()) SWIG_fail;
20417 }
20418 {
20419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20420 }
20421 return resultobj;
20422 fail:
20423 return NULL;
20424 }
20425
20426
20427 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20428 PyObject *resultobj = 0;
20429 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20430 bool result;
20431 void *argp1 = 0 ;
20432 int res1 = 0 ;
20433 PyObject *swig_obj[1] ;
20434
20435 if (!args) SWIG_fail;
20436 swig_obj[0] = args;
20437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20438 if (!SWIG_IsOK(res1)) {
20439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20440 }
20441 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20442 {
20443 PyThreadState* __tstate = wxPyBeginAllowThreads();
20444 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20445 wxPyEndAllowThreads(__tstate);
20446 if (PyErr_Occurred()) SWIG_fail;
20447 }
20448 {
20449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20450 }
20451 return resultobj;
20452 fail:
20453 return NULL;
20454 }
20455
20456
20457 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20458 PyObject *resultobj = 0;
20459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20460 bool result;
20461 void *argp1 = 0 ;
20462 int res1 = 0 ;
20463 PyObject *swig_obj[1] ;
20464
20465 if (!args) SWIG_fail;
20466 swig_obj[0] = args;
20467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20468 if (!SWIG_IsOK(res1)) {
20469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20470 }
20471 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20472 {
20473 PyThreadState* __tstate = wxPyBeginAllowThreads();
20474 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20475 wxPyEndAllowThreads(__tstate);
20476 if (PyErr_Occurred()) SWIG_fail;
20477 }
20478 {
20479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20480 }
20481 return resultobj;
20482 fail:
20483 return NULL;
20484 }
20485
20486
20487 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20488 PyObject *resultobj = 0;
20489 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20490 bool result;
20491 void *argp1 = 0 ;
20492 int res1 = 0 ;
20493 PyObject *swig_obj[1] ;
20494
20495 if (!args) SWIG_fail;
20496 swig_obj[0] = args;
20497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20498 if (!SWIG_IsOK(res1)) {
20499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20500 }
20501 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20502 {
20503 PyThreadState* __tstate = wxPyBeginAllowThreads();
20504 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20505 wxPyEndAllowThreads(__tstate);
20506 if (PyErr_Occurred()) SWIG_fail;
20507 }
20508 {
20509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20510 }
20511 return resultobj;
20512 fail:
20513 return NULL;
20514 }
20515
20516
20517 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20518 PyObject *resultobj = 0;
20519 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20520 bool result;
20521 void *argp1 = 0 ;
20522 int res1 = 0 ;
20523 PyObject *swig_obj[1] ;
20524
20525 if (!args) SWIG_fail;
20526 swig_obj[0] = args;
20527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20528 if (!SWIG_IsOK(res1)) {
20529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20530 }
20531 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20532 {
20533 PyThreadState* __tstate = wxPyBeginAllowThreads();
20534 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20535 wxPyEndAllowThreads(__tstate);
20536 if (PyErr_Occurred()) SWIG_fail;
20537 }
20538 {
20539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20540 }
20541 return resultobj;
20542 fail:
20543 return NULL;
20544 }
20545
20546
20547 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20548 PyObject *resultobj = 0;
20549 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20550 bool result;
20551 void *argp1 = 0 ;
20552 int res1 = 0 ;
20553 PyObject *swig_obj[1] ;
20554
20555 if (!args) SWIG_fail;
20556 swig_obj[0] = args;
20557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20558 if (!SWIG_IsOK(res1)) {
20559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20560 }
20561 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20562 {
20563 PyThreadState* __tstate = wxPyBeginAllowThreads();
20564 result = (bool)(arg1)->LeftIsDown();
20565 wxPyEndAllowThreads(__tstate);
20566 if (PyErr_Occurred()) SWIG_fail;
20567 }
20568 {
20569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20570 }
20571 return resultobj;
20572 fail:
20573 return NULL;
20574 }
20575
20576
20577 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20578 PyObject *resultobj = 0;
20579 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20580 bool result;
20581 void *argp1 = 0 ;
20582 int res1 = 0 ;
20583 PyObject *swig_obj[1] ;
20584
20585 if (!args) SWIG_fail;
20586 swig_obj[0] = args;
20587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20588 if (!SWIG_IsOK(res1)) {
20589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20590 }
20591 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20592 {
20593 PyThreadState* __tstate = wxPyBeginAllowThreads();
20594 result = (bool)(arg1)->MiddleIsDown();
20595 wxPyEndAllowThreads(__tstate);
20596 if (PyErr_Occurred()) SWIG_fail;
20597 }
20598 {
20599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20600 }
20601 return resultobj;
20602 fail:
20603 return NULL;
20604 }
20605
20606
20607 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20608 PyObject *resultobj = 0;
20609 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20610 bool result;
20611 void *argp1 = 0 ;
20612 int res1 = 0 ;
20613 PyObject *swig_obj[1] ;
20614
20615 if (!args) SWIG_fail;
20616 swig_obj[0] = args;
20617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20618 if (!SWIG_IsOK(res1)) {
20619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20620 }
20621 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20622 {
20623 PyThreadState* __tstate = wxPyBeginAllowThreads();
20624 result = (bool)(arg1)->RightIsDown();
20625 wxPyEndAllowThreads(__tstate);
20626 if (PyErr_Occurred()) SWIG_fail;
20627 }
20628 {
20629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20630 }
20631 return resultobj;
20632 fail:
20633 return NULL;
20634 }
20635
20636
20637 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20638 PyObject *resultobj = 0;
20639 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20640 bool result;
20641 void *argp1 = 0 ;
20642 int res1 = 0 ;
20643 PyObject *swig_obj[1] ;
20644
20645 if (!args) SWIG_fail;
20646 swig_obj[0] = args;
20647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20648 if (!SWIG_IsOK(res1)) {
20649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20650 }
20651 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20652 {
20653 PyThreadState* __tstate = wxPyBeginAllowThreads();
20654 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20655 wxPyEndAllowThreads(__tstate);
20656 if (PyErr_Occurred()) SWIG_fail;
20657 }
20658 {
20659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20660 }
20661 return resultobj;
20662 fail:
20663 return NULL;
20664 }
20665
20666
20667 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20668 PyObject *resultobj = 0;
20669 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20670 bool result;
20671 void *argp1 = 0 ;
20672 int res1 = 0 ;
20673 PyObject *swig_obj[1] ;
20674
20675 if (!args) SWIG_fail;
20676 swig_obj[0] = args;
20677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20678 if (!SWIG_IsOK(res1)) {
20679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20680 }
20681 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20682 {
20683 PyThreadState* __tstate = wxPyBeginAllowThreads();
20684 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20685 wxPyEndAllowThreads(__tstate);
20686 if (PyErr_Occurred()) SWIG_fail;
20687 }
20688 {
20689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20690 }
20691 return resultobj;
20692 fail:
20693 return NULL;
20694 }
20695
20696
20697 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20698 PyObject *resultobj = 0;
20699 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20700 bool result;
20701 void *argp1 = 0 ;
20702 int res1 = 0 ;
20703 PyObject *swig_obj[1] ;
20704
20705 if (!args) SWIG_fail;
20706 swig_obj[0] = args;
20707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20708 if (!SWIG_IsOK(res1)) {
20709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20710 }
20711 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20712 {
20713 PyThreadState* __tstate = wxPyBeginAllowThreads();
20714 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20715 wxPyEndAllowThreads(__tstate);
20716 if (PyErr_Occurred()) SWIG_fail;
20717 }
20718 {
20719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20720 }
20721 return resultobj;
20722 fail:
20723 return NULL;
20724 }
20725
20726
20727 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20728 PyObject *resultobj = 0;
20729 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20730 bool result;
20731 void *argp1 = 0 ;
20732 int res1 = 0 ;
20733 PyObject *swig_obj[1] ;
20734
20735 if (!args) SWIG_fail;
20736 swig_obj[0] = args;
20737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20738 if (!SWIG_IsOK(res1)) {
20739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20740 }
20741 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20742 {
20743 PyThreadState* __tstate = wxPyBeginAllowThreads();
20744 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20745 wxPyEndAllowThreads(__tstate);
20746 if (PyErr_Occurred()) SWIG_fail;
20747 }
20748 {
20749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20750 }
20751 return resultobj;
20752 fail:
20753 return NULL;
20754 }
20755
20756
20757 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20758 PyObject *resultobj = 0;
20759 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20760 wxPoint result;
20761 void *argp1 = 0 ;
20762 int res1 = 0 ;
20763 PyObject *swig_obj[1] ;
20764
20765 if (!args) SWIG_fail;
20766 swig_obj[0] = args;
20767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20768 if (!SWIG_IsOK(res1)) {
20769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20770 }
20771 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20772 {
20773 PyThreadState* __tstate = wxPyBeginAllowThreads();
20774 result = (arg1)->GetPosition();
20775 wxPyEndAllowThreads(__tstate);
20776 if (PyErr_Occurred()) SWIG_fail;
20777 }
20778 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20779 return resultobj;
20780 fail:
20781 return NULL;
20782 }
20783
20784
20785 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20786 PyObject *resultobj = 0;
20787 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20788 long *arg2 = (long *) 0 ;
20789 long *arg3 = (long *) 0 ;
20790 void *argp1 = 0 ;
20791 int res1 = 0 ;
20792 long temp2 ;
20793 int res2 = SWIG_TMPOBJ ;
20794 long temp3 ;
20795 int res3 = SWIG_TMPOBJ ;
20796 PyObject *swig_obj[1] ;
20797
20798 arg2 = &temp2;
20799 arg3 = &temp3;
20800 if (!args) SWIG_fail;
20801 swig_obj[0] = args;
20802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20803 if (!SWIG_IsOK(res1)) {
20804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20805 }
20806 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20807 {
20808 PyThreadState* __tstate = wxPyBeginAllowThreads();
20809 (arg1)->GetPosition(arg2,arg3);
20810 wxPyEndAllowThreads(__tstate);
20811 if (PyErr_Occurred()) SWIG_fail;
20812 }
20813 resultobj = SWIG_Py_Void();
20814 if (SWIG_IsTmpObj(res2)) {
20815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20816 } else {
20817 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20818 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20819 }
20820 if (SWIG_IsTmpObj(res3)) {
20821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20822 } else {
20823 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20825 }
20826 return resultobj;
20827 fail:
20828 return NULL;
20829 }
20830
20831
20832 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20833 PyObject *resultobj = 0;
20834 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20835 wxDC *arg2 = 0 ;
20836 wxPoint result;
20837 void *argp1 = 0 ;
20838 int res1 = 0 ;
20839 void *argp2 = 0 ;
20840 int res2 = 0 ;
20841 PyObject * obj0 = 0 ;
20842 PyObject * obj1 = 0 ;
20843 char * kwnames[] = {
20844 (char *) "self",(char *) "dc", NULL
20845 };
20846
20847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20849 if (!SWIG_IsOK(res1)) {
20850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20851 }
20852 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20853 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20854 if (!SWIG_IsOK(res2)) {
20855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20856 }
20857 if (!argp2) {
20858 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20859 }
20860 arg2 = reinterpret_cast< wxDC * >(argp2);
20861 {
20862 PyThreadState* __tstate = wxPyBeginAllowThreads();
20863 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20864 wxPyEndAllowThreads(__tstate);
20865 if (PyErr_Occurred()) SWIG_fail;
20866 }
20867 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20868 return resultobj;
20869 fail:
20870 return NULL;
20871 }
20872
20873
20874 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20875 PyObject *resultobj = 0;
20876 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20877 int result;
20878 void *argp1 = 0 ;
20879 int res1 = 0 ;
20880 PyObject *swig_obj[1] ;
20881
20882 if (!args) SWIG_fail;
20883 swig_obj[0] = args;
20884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20885 if (!SWIG_IsOK(res1)) {
20886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20887 }
20888 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20889 {
20890 PyThreadState* __tstate = wxPyBeginAllowThreads();
20891 result = (int)((wxMouseEvent const *)arg1)->GetX();
20892 wxPyEndAllowThreads(__tstate);
20893 if (PyErr_Occurred()) SWIG_fail;
20894 }
20895 resultobj = SWIG_From_int(static_cast< int >(result));
20896 return resultobj;
20897 fail:
20898 return NULL;
20899 }
20900
20901
20902 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20903 PyObject *resultobj = 0;
20904 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20905 int result;
20906 void *argp1 = 0 ;
20907 int res1 = 0 ;
20908 PyObject *swig_obj[1] ;
20909
20910 if (!args) SWIG_fail;
20911 swig_obj[0] = args;
20912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20913 if (!SWIG_IsOK(res1)) {
20914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20915 }
20916 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20917 {
20918 PyThreadState* __tstate = wxPyBeginAllowThreads();
20919 result = (int)((wxMouseEvent const *)arg1)->GetY();
20920 wxPyEndAllowThreads(__tstate);
20921 if (PyErr_Occurred()) SWIG_fail;
20922 }
20923 resultobj = SWIG_From_int(static_cast< int >(result));
20924 return resultobj;
20925 fail:
20926 return NULL;
20927 }
20928
20929
20930 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20931 PyObject *resultobj = 0;
20932 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20933 int result;
20934 void *argp1 = 0 ;
20935 int res1 = 0 ;
20936 PyObject *swig_obj[1] ;
20937
20938 if (!args) SWIG_fail;
20939 swig_obj[0] = args;
20940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20941 if (!SWIG_IsOK(res1)) {
20942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20943 }
20944 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20945 {
20946 PyThreadState* __tstate = wxPyBeginAllowThreads();
20947 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20948 wxPyEndAllowThreads(__tstate);
20949 if (PyErr_Occurred()) SWIG_fail;
20950 }
20951 resultobj = SWIG_From_int(static_cast< int >(result));
20952 return resultobj;
20953 fail:
20954 return NULL;
20955 }
20956
20957
20958 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20959 PyObject *resultobj = 0;
20960 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20961 int result;
20962 void *argp1 = 0 ;
20963 int res1 = 0 ;
20964 PyObject *swig_obj[1] ;
20965
20966 if (!args) SWIG_fail;
20967 swig_obj[0] = args;
20968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20969 if (!SWIG_IsOK(res1)) {
20970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20971 }
20972 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20973 {
20974 PyThreadState* __tstate = wxPyBeginAllowThreads();
20975 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20976 wxPyEndAllowThreads(__tstate);
20977 if (PyErr_Occurred()) SWIG_fail;
20978 }
20979 resultobj = SWIG_From_int(static_cast< int >(result));
20980 return resultobj;
20981 fail:
20982 return NULL;
20983 }
20984
20985
20986 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20987 PyObject *resultobj = 0;
20988 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20989 int result;
20990 void *argp1 = 0 ;
20991 int res1 = 0 ;
20992 PyObject *swig_obj[1] ;
20993
20994 if (!args) SWIG_fail;
20995 swig_obj[0] = args;
20996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20997 if (!SWIG_IsOK(res1)) {
20998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20999 }
21000 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21001 {
21002 PyThreadState* __tstate = wxPyBeginAllowThreads();
21003 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21004 wxPyEndAllowThreads(__tstate);
21005 if (PyErr_Occurred()) SWIG_fail;
21006 }
21007 resultobj = SWIG_From_int(static_cast< int >(result));
21008 return resultobj;
21009 fail:
21010 return NULL;
21011 }
21012
21013
21014 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21015 PyObject *resultobj = 0;
21016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21017 bool result;
21018 void *argp1 = 0 ;
21019 int res1 = 0 ;
21020 PyObject *swig_obj[1] ;
21021
21022 if (!args) SWIG_fail;
21023 swig_obj[0] = args;
21024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21025 if (!SWIG_IsOK(res1)) {
21026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21027 }
21028 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21029 {
21030 PyThreadState* __tstate = wxPyBeginAllowThreads();
21031 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21032 wxPyEndAllowThreads(__tstate);
21033 if (PyErr_Occurred()) SWIG_fail;
21034 }
21035 {
21036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21037 }
21038 return resultobj;
21039 fail:
21040 return NULL;
21041 }
21042
21043
21044 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21045 PyObject *resultobj = 0;
21046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21047 int arg2 ;
21048 void *argp1 = 0 ;
21049 int res1 = 0 ;
21050 int val2 ;
21051 int ecode2 = 0 ;
21052 PyObject *swig_obj[2] ;
21053
21054 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21056 if (!SWIG_IsOK(res1)) {
21057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21058 }
21059 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21060 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21061 if (!SWIG_IsOK(ecode2)) {
21062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21063 }
21064 arg2 = static_cast< int >(val2);
21065 if (arg1) (arg1)->m_x = arg2;
21066
21067 resultobj = SWIG_Py_Void();
21068 return resultobj;
21069 fail:
21070 return NULL;
21071 }
21072
21073
21074 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21075 PyObject *resultobj = 0;
21076 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21077 int result;
21078 void *argp1 = 0 ;
21079 int res1 = 0 ;
21080 PyObject *swig_obj[1] ;
21081
21082 if (!args) SWIG_fail;
21083 swig_obj[0] = args;
21084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21085 if (!SWIG_IsOK(res1)) {
21086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21087 }
21088 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21089 result = (int) ((arg1)->m_x);
21090 resultobj = SWIG_From_int(static_cast< int >(result));
21091 return resultobj;
21092 fail:
21093 return NULL;
21094 }
21095
21096
21097 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21098 PyObject *resultobj = 0;
21099 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21100 int arg2 ;
21101 void *argp1 = 0 ;
21102 int res1 = 0 ;
21103 int val2 ;
21104 int ecode2 = 0 ;
21105 PyObject *swig_obj[2] ;
21106
21107 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21109 if (!SWIG_IsOK(res1)) {
21110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21111 }
21112 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21113 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21114 if (!SWIG_IsOK(ecode2)) {
21115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21116 }
21117 arg2 = static_cast< int >(val2);
21118 if (arg1) (arg1)->m_y = arg2;
21119
21120 resultobj = SWIG_Py_Void();
21121 return resultobj;
21122 fail:
21123 return NULL;
21124 }
21125
21126
21127 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21128 PyObject *resultobj = 0;
21129 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21130 int result;
21131 void *argp1 = 0 ;
21132 int res1 = 0 ;
21133 PyObject *swig_obj[1] ;
21134
21135 if (!args) SWIG_fail;
21136 swig_obj[0] = args;
21137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21138 if (!SWIG_IsOK(res1)) {
21139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21140 }
21141 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21142 result = (int) ((arg1)->m_y);
21143 resultobj = SWIG_From_int(static_cast< int >(result));
21144 return resultobj;
21145 fail:
21146 return NULL;
21147 }
21148
21149
21150 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21151 PyObject *resultobj = 0;
21152 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21153 bool arg2 ;
21154 void *argp1 = 0 ;
21155 int res1 = 0 ;
21156 bool val2 ;
21157 int ecode2 = 0 ;
21158 PyObject *swig_obj[2] ;
21159
21160 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21162 if (!SWIG_IsOK(res1)) {
21163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21164 }
21165 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21166 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21167 if (!SWIG_IsOK(ecode2)) {
21168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21169 }
21170 arg2 = static_cast< bool >(val2);
21171 if (arg1) (arg1)->m_leftDown = arg2;
21172
21173 resultobj = SWIG_Py_Void();
21174 return resultobj;
21175 fail:
21176 return NULL;
21177 }
21178
21179
21180 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21181 PyObject *resultobj = 0;
21182 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21183 bool result;
21184 void *argp1 = 0 ;
21185 int res1 = 0 ;
21186 PyObject *swig_obj[1] ;
21187
21188 if (!args) SWIG_fail;
21189 swig_obj[0] = args;
21190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21191 if (!SWIG_IsOK(res1)) {
21192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21193 }
21194 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21195 result = (bool) ((arg1)->m_leftDown);
21196 {
21197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21198 }
21199 return resultobj;
21200 fail:
21201 return NULL;
21202 }
21203
21204
21205 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21206 PyObject *resultobj = 0;
21207 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21208 bool arg2 ;
21209 void *argp1 = 0 ;
21210 int res1 = 0 ;
21211 bool val2 ;
21212 int ecode2 = 0 ;
21213 PyObject *swig_obj[2] ;
21214
21215 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21217 if (!SWIG_IsOK(res1)) {
21218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21219 }
21220 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21221 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21222 if (!SWIG_IsOK(ecode2)) {
21223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21224 }
21225 arg2 = static_cast< bool >(val2);
21226 if (arg1) (arg1)->m_middleDown = arg2;
21227
21228 resultobj = SWIG_Py_Void();
21229 return resultobj;
21230 fail:
21231 return NULL;
21232 }
21233
21234
21235 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21236 PyObject *resultobj = 0;
21237 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21238 bool result;
21239 void *argp1 = 0 ;
21240 int res1 = 0 ;
21241 PyObject *swig_obj[1] ;
21242
21243 if (!args) SWIG_fail;
21244 swig_obj[0] = args;
21245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21246 if (!SWIG_IsOK(res1)) {
21247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21248 }
21249 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21250 result = (bool) ((arg1)->m_middleDown);
21251 {
21252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21253 }
21254 return resultobj;
21255 fail:
21256 return NULL;
21257 }
21258
21259
21260 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21261 PyObject *resultobj = 0;
21262 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21263 bool arg2 ;
21264 void *argp1 = 0 ;
21265 int res1 = 0 ;
21266 bool val2 ;
21267 int ecode2 = 0 ;
21268 PyObject *swig_obj[2] ;
21269
21270 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21272 if (!SWIG_IsOK(res1)) {
21273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21274 }
21275 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21276 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21277 if (!SWIG_IsOK(ecode2)) {
21278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21279 }
21280 arg2 = static_cast< bool >(val2);
21281 if (arg1) (arg1)->m_rightDown = arg2;
21282
21283 resultobj = SWIG_Py_Void();
21284 return resultobj;
21285 fail:
21286 return NULL;
21287 }
21288
21289
21290 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21291 PyObject *resultobj = 0;
21292 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21293 bool result;
21294 void *argp1 = 0 ;
21295 int res1 = 0 ;
21296 PyObject *swig_obj[1] ;
21297
21298 if (!args) SWIG_fail;
21299 swig_obj[0] = args;
21300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21301 if (!SWIG_IsOK(res1)) {
21302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21303 }
21304 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21305 result = (bool) ((arg1)->m_rightDown);
21306 {
21307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21308 }
21309 return resultobj;
21310 fail:
21311 return NULL;
21312 }
21313
21314
21315 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21316 PyObject *resultobj = 0;
21317 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21318 bool arg2 ;
21319 void *argp1 = 0 ;
21320 int res1 = 0 ;
21321 bool val2 ;
21322 int ecode2 = 0 ;
21323 PyObject *swig_obj[2] ;
21324
21325 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21327 if (!SWIG_IsOK(res1)) {
21328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21329 }
21330 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21331 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21332 if (!SWIG_IsOK(ecode2)) {
21333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21334 }
21335 arg2 = static_cast< bool >(val2);
21336 if (arg1) (arg1)->m_controlDown = arg2;
21337
21338 resultobj = SWIG_Py_Void();
21339 return resultobj;
21340 fail:
21341 return NULL;
21342 }
21343
21344
21345 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21346 PyObject *resultobj = 0;
21347 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21348 bool result;
21349 void *argp1 = 0 ;
21350 int res1 = 0 ;
21351 PyObject *swig_obj[1] ;
21352
21353 if (!args) SWIG_fail;
21354 swig_obj[0] = args;
21355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21356 if (!SWIG_IsOK(res1)) {
21357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21358 }
21359 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21360 result = (bool) ((arg1)->m_controlDown);
21361 {
21362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21363 }
21364 return resultobj;
21365 fail:
21366 return NULL;
21367 }
21368
21369
21370 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21371 PyObject *resultobj = 0;
21372 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21373 bool arg2 ;
21374 void *argp1 = 0 ;
21375 int res1 = 0 ;
21376 bool val2 ;
21377 int ecode2 = 0 ;
21378 PyObject *swig_obj[2] ;
21379
21380 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21382 if (!SWIG_IsOK(res1)) {
21383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21384 }
21385 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21386 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21387 if (!SWIG_IsOK(ecode2)) {
21388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21389 }
21390 arg2 = static_cast< bool >(val2);
21391 if (arg1) (arg1)->m_shiftDown = arg2;
21392
21393 resultobj = SWIG_Py_Void();
21394 return resultobj;
21395 fail:
21396 return NULL;
21397 }
21398
21399
21400 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21401 PyObject *resultobj = 0;
21402 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21403 bool result;
21404 void *argp1 = 0 ;
21405 int res1 = 0 ;
21406 PyObject *swig_obj[1] ;
21407
21408 if (!args) SWIG_fail;
21409 swig_obj[0] = args;
21410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21411 if (!SWIG_IsOK(res1)) {
21412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21413 }
21414 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21415 result = (bool) ((arg1)->m_shiftDown);
21416 {
21417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21418 }
21419 return resultobj;
21420 fail:
21421 return NULL;
21422 }
21423
21424
21425 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21426 PyObject *resultobj = 0;
21427 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21428 bool arg2 ;
21429 void *argp1 = 0 ;
21430 int res1 = 0 ;
21431 bool val2 ;
21432 int ecode2 = 0 ;
21433 PyObject *swig_obj[2] ;
21434
21435 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21437 if (!SWIG_IsOK(res1)) {
21438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21439 }
21440 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21441 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21442 if (!SWIG_IsOK(ecode2)) {
21443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21444 }
21445 arg2 = static_cast< bool >(val2);
21446 if (arg1) (arg1)->m_altDown = arg2;
21447
21448 resultobj = SWIG_Py_Void();
21449 return resultobj;
21450 fail:
21451 return NULL;
21452 }
21453
21454
21455 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21456 PyObject *resultobj = 0;
21457 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21458 bool result;
21459 void *argp1 = 0 ;
21460 int res1 = 0 ;
21461 PyObject *swig_obj[1] ;
21462
21463 if (!args) SWIG_fail;
21464 swig_obj[0] = args;
21465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21466 if (!SWIG_IsOK(res1)) {
21467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21468 }
21469 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21470 result = (bool) ((arg1)->m_altDown);
21471 {
21472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21473 }
21474 return resultobj;
21475 fail:
21476 return NULL;
21477 }
21478
21479
21480 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21481 PyObject *resultobj = 0;
21482 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21483 bool arg2 ;
21484 void *argp1 = 0 ;
21485 int res1 = 0 ;
21486 bool val2 ;
21487 int ecode2 = 0 ;
21488 PyObject *swig_obj[2] ;
21489
21490 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21492 if (!SWIG_IsOK(res1)) {
21493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21494 }
21495 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21496 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21497 if (!SWIG_IsOK(ecode2)) {
21498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21499 }
21500 arg2 = static_cast< bool >(val2);
21501 if (arg1) (arg1)->m_metaDown = arg2;
21502
21503 resultobj = SWIG_Py_Void();
21504 return resultobj;
21505 fail:
21506 return NULL;
21507 }
21508
21509
21510 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21511 PyObject *resultobj = 0;
21512 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21513 bool result;
21514 void *argp1 = 0 ;
21515 int res1 = 0 ;
21516 PyObject *swig_obj[1] ;
21517
21518 if (!args) SWIG_fail;
21519 swig_obj[0] = args;
21520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21521 if (!SWIG_IsOK(res1)) {
21522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21523 }
21524 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21525 result = (bool) ((arg1)->m_metaDown);
21526 {
21527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21528 }
21529 return resultobj;
21530 fail:
21531 return NULL;
21532 }
21533
21534
21535 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21536 PyObject *resultobj = 0;
21537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21538 int arg2 ;
21539 void *argp1 = 0 ;
21540 int res1 = 0 ;
21541 int val2 ;
21542 int ecode2 = 0 ;
21543 PyObject *swig_obj[2] ;
21544
21545 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21547 if (!SWIG_IsOK(res1)) {
21548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21549 }
21550 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21551 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21552 if (!SWIG_IsOK(ecode2)) {
21553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21554 }
21555 arg2 = static_cast< int >(val2);
21556 if (arg1) (arg1)->m_wheelRotation = arg2;
21557
21558 resultobj = SWIG_Py_Void();
21559 return resultobj;
21560 fail:
21561 return NULL;
21562 }
21563
21564
21565 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21566 PyObject *resultobj = 0;
21567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21568 int result;
21569 void *argp1 = 0 ;
21570 int res1 = 0 ;
21571 PyObject *swig_obj[1] ;
21572
21573 if (!args) SWIG_fail;
21574 swig_obj[0] = args;
21575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21576 if (!SWIG_IsOK(res1)) {
21577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21578 }
21579 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21580 result = (int) ((arg1)->m_wheelRotation);
21581 resultobj = SWIG_From_int(static_cast< int >(result));
21582 return resultobj;
21583 fail:
21584 return NULL;
21585 }
21586
21587
21588 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21589 PyObject *resultobj = 0;
21590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21591 int arg2 ;
21592 void *argp1 = 0 ;
21593 int res1 = 0 ;
21594 int val2 ;
21595 int ecode2 = 0 ;
21596 PyObject *swig_obj[2] ;
21597
21598 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21600 if (!SWIG_IsOK(res1)) {
21601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21602 }
21603 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21604 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21605 if (!SWIG_IsOK(ecode2)) {
21606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21607 }
21608 arg2 = static_cast< int >(val2);
21609 if (arg1) (arg1)->m_wheelDelta = arg2;
21610
21611 resultobj = SWIG_Py_Void();
21612 return resultobj;
21613 fail:
21614 return NULL;
21615 }
21616
21617
21618 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21619 PyObject *resultobj = 0;
21620 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21621 int result;
21622 void *argp1 = 0 ;
21623 int res1 = 0 ;
21624 PyObject *swig_obj[1] ;
21625
21626 if (!args) SWIG_fail;
21627 swig_obj[0] = args;
21628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21629 if (!SWIG_IsOK(res1)) {
21630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21631 }
21632 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21633 result = (int) ((arg1)->m_wheelDelta);
21634 resultobj = SWIG_From_int(static_cast< int >(result));
21635 return resultobj;
21636 fail:
21637 return NULL;
21638 }
21639
21640
21641 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21642 PyObject *resultobj = 0;
21643 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21644 int arg2 ;
21645 void *argp1 = 0 ;
21646 int res1 = 0 ;
21647 int val2 ;
21648 int ecode2 = 0 ;
21649 PyObject *swig_obj[2] ;
21650
21651 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21653 if (!SWIG_IsOK(res1)) {
21654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21655 }
21656 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21657 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21658 if (!SWIG_IsOK(ecode2)) {
21659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21660 }
21661 arg2 = static_cast< int >(val2);
21662 if (arg1) (arg1)->m_linesPerAction = arg2;
21663
21664 resultobj = SWIG_Py_Void();
21665 return resultobj;
21666 fail:
21667 return NULL;
21668 }
21669
21670
21671 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21672 PyObject *resultobj = 0;
21673 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21674 int result;
21675 void *argp1 = 0 ;
21676 int res1 = 0 ;
21677 PyObject *swig_obj[1] ;
21678
21679 if (!args) SWIG_fail;
21680 swig_obj[0] = args;
21681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21682 if (!SWIG_IsOK(res1)) {
21683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21684 }
21685 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21686 result = (int) ((arg1)->m_linesPerAction);
21687 resultobj = SWIG_From_int(static_cast< int >(result));
21688 return resultobj;
21689 fail:
21690 return NULL;
21691 }
21692
21693
21694 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21695 PyObject *obj;
21696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21697 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21698 return SWIG_Py_Void();
21699 }
21700
21701 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21702 return SWIG_Python_InitShadowInstance(args);
21703 }
21704
21705 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21706 PyObject *resultobj = 0;
21707 int arg1 = (int) 0 ;
21708 int arg2 = (int) 0 ;
21709 wxSetCursorEvent *result = 0 ;
21710 int val1 ;
21711 int ecode1 = 0 ;
21712 int val2 ;
21713 int ecode2 = 0 ;
21714 PyObject * obj0 = 0 ;
21715 PyObject * obj1 = 0 ;
21716 char * kwnames[] = {
21717 (char *) "x",(char *) "y", NULL
21718 };
21719
21720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21721 if (obj0) {
21722 ecode1 = SWIG_AsVal_int(obj0, &val1);
21723 if (!SWIG_IsOK(ecode1)) {
21724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21725 }
21726 arg1 = static_cast< int >(val1);
21727 }
21728 if (obj1) {
21729 ecode2 = SWIG_AsVal_int(obj1, &val2);
21730 if (!SWIG_IsOK(ecode2)) {
21731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21732 }
21733 arg2 = static_cast< int >(val2);
21734 }
21735 {
21736 PyThreadState* __tstate = wxPyBeginAllowThreads();
21737 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21738 wxPyEndAllowThreads(__tstate);
21739 if (PyErr_Occurred()) SWIG_fail;
21740 }
21741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21742 return resultobj;
21743 fail:
21744 return NULL;
21745 }
21746
21747
21748 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21749 PyObject *resultobj = 0;
21750 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21751 int result;
21752 void *argp1 = 0 ;
21753 int res1 = 0 ;
21754 PyObject *swig_obj[1] ;
21755
21756 if (!args) SWIG_fail;
21757 swig_obj[0] = args;
21758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21759 if (!SWIG_IsOK(res1)) {
21760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21761 }
21762 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21763 {
21764 PyThreadState* __tstate = wxPyBeginAllowThreads();
21765 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21766 wxPyEndAllowThreads(__tstate);
21767 if (PyErr_Occurred()) SWIG_fail;
21768 }
21769 resultobj = SWIG_From_int(static_cast< int >(result));
21770 return resultobj;
21771 fail:
21772 return NULL;
21773 }
21774
21775
21776 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21777 PyObject *resultobj = 0;
21778 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21779 int result;
21780 void *argp1 = 0 ;
21781 int res1 = 0 ;
21782 PyObject *swig_obj[1] ;
21783
21784 if (!args) SWIG_fail;
21785 swig_obj[0] = args;
21786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21787 if (!SWIG_IsOK(res1)) {
21788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21789 }
21790 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21791 {
21792 PyThreadState* __tstate = wxPyBeginAllowThreads();
21793 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21794 wxPyEndAllowThreads(__tstate);
21795 if (PyErr_Occurred()) SWIG_fail;
21796 }
21797 resultobj = SWIG_From_int(static_cast< int >(result));
21798 return resultobj;
21799 fail:
21800 return NULL;
21801 }
21802
21803
21804 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21805 PyObject *resultobj = 0;
21806 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21807 wxCursor *arg2 = 0 ;
21808 void *argp1 = 0 ;
21809 int res1 = 0 ;
21810 void *argp2 = 0 ;
21811 int res2 = 0 ;
21812 PyObject * obj0 = 0 ;
21813 PyObject * obj1 = 0 ;
21814 char * kwnames[] = {
21815 (char *) "self",(char *) "cursor", NULL
21816 };
21817
21818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21820 if (!SWIG_IsOK(res1)) {
21821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21822 }
21823 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21824 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21825 if (!SWIG_IsOK(res2)) {
21826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21827 }
21828 if (!argp2) {
21829 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21830 }
21831 arg2 = reinterpret_cast< wxCursor * >(argp2);
21832 {
21833 PyThreadState* __tstate = wxPyBeginAllowThreads();
21834 (arg1)->SetCursor((wxCursor const &)*arg2);
21835 wxPyEndAllowThreads(__tstate);
21836 if (PyErr_Occurred()) SWIG_fail;
21837 }
21838 resultobj = SWIG_Py_Void();
21839 return resultobj;
21840 fail:
21841 return NULL;
21842 }
21843
21844
21845 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21846 PyObject *resultobj = 0;
21847 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21848 wxCursor *result = 0 ;
21849 void *argp1 = 0 ;
21850 int res1 = 0 ;
21851 PyObject *swig_obj[1] ;
21852
21853 if (!args) SWIG_fail;
21854 swig_obj[0] = args;
21855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21856 if (!SWIG_IsOK(res1)) {
21857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21858 }
21859 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21860 {
21861 PyThreadState* __tstate = wxPyBeginAllowThreads();
21862 {
21863 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21864 result = (wxCursor *) &_result_ref;
21865 }
21866 wxPyEndAllowThreads(__tstate);
21867 if (PyErr_Occurred()) SWIG_fail;
21868 }
21869 {
21870 wxCursor* resultptr = new wxCursor(*result);
21871 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21872 }
21873 return resultobj;
21874 fail:
21875 return NULL;
21876 }
21877
21878
21879 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21880 PyObject *resultobj = 0;
21881 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21882 bool result;
21883 void *argp1 = 0 ;
21884 int res1 = 0 ;
21885 PyObject *swig_obj[1] ;
21886
21887 if (!args) SWIG_fail;
21888 swig_obj[0] = args;
21889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21890 if (!SWIG_IsOK(res1)) {
21891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21892 }
21893 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21894 {
21895 PyThreadState* __tstate = wxPyBeginAllowThreads();
21896 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21897 wxPyEndAllowThreads(__tstate);
21898 if (PyErr_Occurred()) SWIG_fail;
21899 }
21900 {
21901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21902 }
21903 return resultobj;
21904 fail:
21905 return NULL;
21906 }
21907
21908
21909 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21910 PyObject *obj;
21911 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21912 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21913 return SWIG_Py_Void();
21914 }
21915
21916 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21917 return SWIG_Python_InitShadowInstance(args);
21918 }
21919
21920 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21921 PyObject *resultobj = 0;
21922 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21923 wxKeyEvent *result = 0 ;
21924 int val1 ;
21925 int ecode1 = 0 ;
21926 PyObject * obj0 = 0 ;
21927 char * kwnames[] = {
21928 (char *) "eventType", NULL
21929 };
21930
21931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21932 if (obj0) {
21933 ecode1 = SWIG_AsVal_int(obj0, &val1);
21934 if (!SWIG_IsOK(ecode1)) {
21935 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21936 }
21937 arg1 = static_cast< wxEventType >(val1);
21938 }
21939 {
21940 PyThreadState* __tstate = wxPyBeginAllowThreads();
21941 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21942 wxPyEndAllowThreads(__tstate);
21943 if (PyErr_Occurred()) SWIG_fail;
21944 }
21945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21946 return resultobj;
21947 fail:
21948 return NULL;
21949 }
21950
21951
21952 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21953 PyObject *resultobj = 0;
21954 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21955 int result;
21956 void *argp1 = 0 ;
21957 int res1 = 0 ;
21958 PyObject *swig_obj[1] ;
21959
21960 if (!args) SWIG_fail;
21961 swig_obj[0] = args;
21962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21963 if (!SWIG_IsOK(res1)) {
21964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21965 }
21966 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21967 {
21968 PyThreadState* __tstate = wxPyBeginAllowThreads();
21969 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21970 wxPyEndAllowThreads(__tstate);
21971 if (PyErr_Occurred()) SWIG_fail;
21972 }
21973 resultobj = SWIG_From_int(static_cast< int >(result));
21974 return resultobj;
21975 fail:
21976 return NULL;
21977 }
21978
21979
21980 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21981 PyObject *resultobj = 0;
21982 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21983 bool result;
21984 void *argp1 = 0 ;
21985 int res1 = 0 ;
21986 PyObject *swig_obj[1] ;
21987
21988 if (!args) SWIG_fail;
21989 swig_obj[0] = args;
21990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21991 if (!SWIG_IsOK(res1)) {
21992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21993 }
21994 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21995 {
21996 PyThreadState* __tstate = wxPyBeginAllowThreads();
21997 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21998 wxPyEndAllowThreads(__tstate);
21999 if (PyErr_Occurred()) SWIG_fail;
22000 }
22001 {
22002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22003 }
22004 return resultobj;
22005 fail:
22006 return NULL;
22007 }
22008
22009
22010 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22011 PyObject *resultobj = 0;
22012 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22013 bool result;
22014 void *argp1 = 0 ;
22015 int res1 = 0 ;
22016 PyObject *swig_obj[1] ;
22017
22018 if (!args) SWIG_fail;
22019 swig_obj[0] = args;
22020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22021 if (!SWIG_IsOK(res1)) {
22022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22023 }
22024 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22025 {
22026 PyThreadState* __tstate = wxPyBeginAllowThreads();
22027 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22028 wxPyEndAllowThreads(__tstate);
22029 if (PyErr_Occurred()) SWIG_fail;
22030 }
22031 {
22032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22033 }
22034 return resultobj;
22035 fail:
22036 return NULL;
22037 }
22038
22039
22040 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22041 PyObject *resultobj = 0;
22042 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22043 bool result;
22044 void *argp1 = 0 ;
22045 int res1 = 0 ;
22046 PyObject *swig_obj[1] ;
22047
22048 if (!args) SWIG_fail;
22049 swig_obj[0] = args;
22050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22051 if (!SWIG_IsOK(res1)) {
22052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22053 }
22054 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22055 {
22056 PyThreadState* __tstate = wxPyBeginAllowThreads();
22057 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22058 wxPyEndAllowThreads(__tstate);
22059 if (PyErr_Occurred()) SWIG_fail;
22060 }
22061 {
22062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22063 }
22064 return resultobj;
22065 fail:
22066 return NULL;
22067 }
22068
22069
22070 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22071 PyObject *resultobj = 0;
22072 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22073 bool result;
22074 void *argp1 = 0 ;
22075 int res1 = 0 ;
22076 PyObject *swig_obj[1] ;
22077
22078 if (!args) SWIG_fail;
22079 swig_obj[0] = args;
22080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22081 if (!SWIG_IsOK(res1)) {
22082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22083 }
22084 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22085 {
22086 PyThreadState* __tstate = wxPyBeginAllowThreads();
22087 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22088 wxPyEndAllowThreads(__tstate);
22089 if (PyErr_Occurred()) SWIG_fail;
22090 }
22091 {
22092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22093 }
22094 return resultobj;
22095 fail:
22096 return NULL;
22097 }
22098
22099
22100 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22101 PyObject *resultobj = 0;
22102 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22103 bool result;
22104 void *argp1 = 0 ;
22105 int res1 = 0 ;
22106 PyObject *swig_obj[1] ;
22107
22108 if (!args) SWIG_fail;
22109 swig_obj[0] = args;
22110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22111 if (!SWIG_IsOK(res1)) {
22112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22113 }
22114 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22115 {
22116 PyThreadState* __tstate = wxPyBeginAllowThreads();
22117 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22118 wxPyEndAllowThreads(__tstate);
22119 if (PyErr_Occurred()) SWIG_fail;
22120 }
22121 {
22122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22123 }
22124 return resultobj;
22125 fail:
22126 return NULL;
22127 }
22128
22129
22130 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22131 PyObject *resultobj = 0;
22132 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22133 bool result;
22134 void *argp1 = 0 ;
22135 int res1 = 0 ;
22136 PyObject *swig_obj[1] ;
22137
22138 if (!args) SWIG_fail;
22139 swig_obj[0] = args;
22140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22141 if (!SWIG_IsOK(res1)) {
22142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22143 }
22144 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22145 {
22146 PyThreadState* __tstate = wxPyBeginAllowThreads();
22147 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22148 wxPyEndAllowThreads(__tstate);
22149 if (PyErr_Occurred()) SWIG_fail;
22150 }
22151 {
22152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22153 }
22154 return resultobj;
22155 fail:
22156 return NULL;
22157 }
22158
22159
22160 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22161 PyObject *resultobj = 0;
22162 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22163 int result;
22164 void *argp1 = 0 ;
22165 int res1 = 0 ;
22166 PyObject *swig_obj[1] ;
22167
22168 if (!args) SWIG_fail;
22169 swig_obj[0] = args;
22170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22171 if (!SWIG_IsOK(res1)) {
22172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22173 }
22174 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22175 {
22176 PyThreadState* __tstate = wxPyBeginAllowThreads();
22177 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22178 wxPyEndAllowThreads(__tstate);
22179 if (PyErr_Occurred()) SWIG_fail;
22180 }
22181 resultobj = SWIG_From_int(static_cast< int >(result));
22182 return resultobj;
22183 fail:
22184 return NULL;
22185 }
22186
22187
22188 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22189 PyObject *resultobj = 0;
22190 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22191 int result;
22192 void *argp1 = 0 ;
22193 int res1 = 0 ;
22194 PyObject *swig_obj[1] ;
22195
22196 if (!args) SWIG_fail;
22197 swig_obj[0] = args;
22198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22199 if (!SWIG_IsOK(res1)) {
22200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22201 }
22202 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22203 {
22204 PyThreadState* __tstate = wxPyBeginAllowThreads();
22205 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22206 wxPyEndAllowThreads(__tstate);
22207 if (PyErr_Occurred()) SWIG_fail;
22208 }
22209 resultobj = SWIG_From_int(static_cast< int >(result));
22210 return resultobj;
22211 fail:
22212 return NULL;
22213 }
22214
22215
22216 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22217 PyObject *resultobj = 0;
22218 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22219 int arg2 ;
22220 void *argp1 = 0 ;
22221 int res1 = 0 ;
22222 int val2 ;
22223 int ecode2 = 0 ;
22224 PyObject * obj0 = 0 ;
22225 PyObject * obj1 = 0 ;
22226 char * kwnames[] = {
22227 (char *) "self",(char *) "uniChar", NULL
22228 };
22229
22230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22232 if (!SWIG_IsOK(res1)) {
22233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22234 }
22235 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22236 ecode2 = SWIG_AsVal_int(obj1, &val2);
22237 if (!SWIG_IsOK(ecode2)) {
22238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22239 }
22240 arg2 = static_cast< int >(val2);
22241 {
22242 PyThreadState* __tstate = wxPyBeginAllowThreads();
22243 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22244 wxPyEndAllowThreads(__tstate);
22245 if (PyErr_Occurred()) SWIG_fail;
22246 }
22247 resultobj = SWIG_Py_Void();
22248 return resultobj;
22249 fail:
22250 return NULL;
22251 }
22252
22253
22254 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22255 PyObject *resultobj = 0;
22256 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22257 unsigned int result;
22258 void *argp1 = 0 ;
22259 int res1 = 0 ;
22260 PyObject *swig_obj[1] ;
22261
22262 if (!args) SWIG_fail;
22263 swig_obj[0] = args;
22264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22265 if (!SWIG_IsOK(res1)) {
22266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22267 }
22268 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22269 {
22270 PyThreadState* __tstate = wxPyBeginAllowThreads();
22271 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22272 wxPyEndAllowThreads(__tstate);
22273 if (PyErr_Occurred()) SWIG_fail;
22274 }
22275 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22276 return resultobj;
22277 fail:
22278 return NULL;
22279 }
22280
22281
22282 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22283 PyObject *resultobj = 0;
22284 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22285 unsigned int result;
22286 void *argp1 = 0 ;
22287 int res1 = 0 ;
22288 PyObject *swig_obj[1] ;
22289
22290 if (!args) SWIG_fail;
22291 swig_obj[0] = args;
22292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22293 if (!SWIG_IsOK(res1)) {
22294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22295 }
22296 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22297 {
22298 PyThreadState* __tstate = wxPyBeginAllowThreads();
22299 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22300 wxPyEndAllowThreads(__tstate);
22301 if (PyErr_Occurred()) SWIG_fail;
22302 }
22303 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22304 return resultobj;
22305 fail:
22306 return NULL;
22307 }
22308
22309
22310 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22311 PyObject *resultobj = 0;
22312 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22313 wxPoint result;
22314 void *argp1 = 0 ;
22315 int res1 = 0 ;
22316 PyObject *swig_obj[1] ;
22317
22318 if (!args) SWIG_fail;
22319 swig_obj[0] = args;
22320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22321 if (!SWIG_IsOK(res1)) {
22322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22323 }
22324 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22325 {
22326 PyThreadState* __tstate = wxPyBeginAllowThreads();
22327 result = (arg1)->GetPosition();
22328 wxPyEndAllowThreads(__tstate);
22329 if (PyErr_Occurred()) SWIG_fail;
22330 }
22331 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22332 return resultobj;
22333 fail:
22334 return NULL;
22335 }
22336
22337
22338 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22339 PyObject *resultobj = 0;
22340 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22341 long *arg2 = (long *) 0 ;
22342 long *arg3 = (long *) 0 ;
22343 void *argp1 = 0 ;
22344 int res1 = 0 ;
22345 long temp2 ;
22346 int res2 = SWIG_TMPOBJ ;
22347 long temp3 ;
22348 int res3 = SWIG_TMPOBJ ;
22349 PyObject *swig_obj[1] ;
22350
22351 arg2 = &temp2;
22352 arg3 = &temp3;
22353 if (!args) SWIG_fail;
22354 swig_obj[0] = args;
22355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22356 if (!SWIG_IsOK(res1)) {
22357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22358 }
22359 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22360 {
22361 PyThreadState* __tstate = wxPyBeginAllowThreads();
22362 (arg1)->GetPosition(arg2,arg3);
22363 wxPyEndAllowThreads(__tstate);
22364 if (PyErr_Occurred()) SWIG_fail;
22365 }
22366 resultobj = SWIG_Py_Void();
22367 if (SWIG_IsTmpObj(res2)) {
22368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22369 } else {
22370 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22372 }
22373 if (SWIG_IsTmpObj(res3)) {
22374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22375 } else {
22376 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22378 }
22379 return resultobj;
22380 fail:
22381 return NULL;
22382 }
22383
22384
22385 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22386 PyObject *resultobj = 0;
22387 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22388 int result;
22389 void *argp1 = 0 ;
22390 int res1 = 0 ;
22391 PyObject *swig_obj[1] ;
22392
22393 if (!args) SWIG_fail;
22394 swig_obj[0] = args;
22395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22396 if (!SWIG_IsOK(res1)) {
22397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22398 }
22399 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22400 {
22401 PyThreadState* __tstate = wxPyBeginAllowThreads();
22402 result = (int)((wxKeyEvent const *)arg1)->GetX();
22403 wxPyEndAllowThreads(__tstate);
22404 if (PyErr_Occurred()) SWIG_fail;
22405 }
22406 resultobj = SWIG_From_int(static_cast< int >(result));
22407 return resultobj;
22408 fail:
22409 return NULL;
22410 }
22411
22412
22413 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22414 PyObject *resultobj = 0;
22415 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22416 int result;
22417 void *argp1 = 0 ;
22418 int res1 = 0 ;
22419 PyObject *swig_obj[1] ;
22420
22421 if (!args) SWIG_fail;
22422 swig_obj[0] = args;
22423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22424 if (!SWIG_IsOK(res1)) {
22425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22426 }
22427 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22428 {
22429 PyThreadState* __tstate = wxPyBeginAllowThreads();
22430 result = (int)((wxKeyEvent const *)arg1)->GetY();
22431 wxPyEndAllowThreads(__tstate);
22432 if (PyErr_Occurred()) SWIG_fail;
22433 }
22434 resultobj = SWIG_From_int(static_cast< int >(result));
22435 return resultobj;
22436 fail:
22437 return NULL;
22438 }
22439
22440
22441 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22442 PyObject *resultobj = 0;
22443 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22444 int arg2 ;
22445 void *argp1 = 0 ;
22446 int res1 = 0 ;
22447 int val2 ;
22448 int ecode2 = 0 ;
22449 PyObject *swig_obj[2] ;
22450
22451 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22453 if (!SWIG_IsOK(res1)) {
22454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22455 }
22456 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22457 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22458 if (!SWIG_IsOK(ecode2)) {
22459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22460 }
22461 arg2 = static_cast< int >(val2);
22462 if (arg1) (arg1)->m_x = arg2;
22463
22464 resultobj = SWIG_Py_Void();
22465 return resultobj;
22466 fail:
22467 return NULL;
22468 }
22469
22470
22471 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22472 PyObject *resultobj = 0;
22473 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22474 int result;
22475 void *argp1 = 0 ;
22476 int res1 = 0 ;
22477 PyObject *swig_obj[1] ;
22478
22479 if (!args) SWIG_fail;
22480 swig_obj[0] = args;
22481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22482 if (!SWIG_IsOK(res1)) {
22483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22484 }
22485 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22486 result = (int) ((arg1)->m_x);
22487 resultobj = SWIG_From_int(static_cast< int >(result));
22488 return resultobj;
22489 fail:
22490 return NULL;
22491 }
22492
22493
22494 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22495 PyObject *resultobj = 0;
22496 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22497 int arg2 ;
22498 void *argp1 = 0 ;
22499 int res1 = 0 ;
22500 int val2 ;
22501 int ecode2 = 0 ;
22502 PyObject *swig_obj[2] ;
22503
22504 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22506 if (!SWIG_IsOK(res1)) {
22507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22508 }
22509 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22510 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22511 if (!SWIG_IsOK(ecode2)) {
22512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22513 }
22514 arg2 = static_cast< int >(val2);
22515 if (arg1) (arg1)->m_y = arg2;
22516
22517 resultobj = SWIG_Py_Void();
22518 return resultobj;
22519 fail:
22520 return NULL;
22521 }
22522
22523
22524 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22525 PyObject *resultobj = 0;
22526 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22527 int result;
22528 void *argp1 = 0 ;
22529 int res1 = 0 ;
22530 PyObject *swig_obj[1] ;
22531
22532 if (!args) SWIG_fail;
22533 swig_obj[0] = args;
22534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22535 if (!SWIG_IsOK(res1)) {
22536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22537 }
22538 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22539 result = (int) ((arg1)->m_y);
22540 resultobj = SWIG_From_int(static_cast< int >(result));
22541 return resultobj;
22542 fail:
22543 return NULL;
22544 }
22545
22546
22547 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22548 PyObject *resultobj = 0;
22549 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22550 long arg2 ;
22551 void *argp1 = 0 ;
22552 int res1 = 0 ;
22553 long val2 ;
22554 int ecode2 = 0 ;
22555 PyObject *swig_obj[2] ;
22556
22557 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22559 if (!SWIG_IsOK(res1)) {
22560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22561 }
22562 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22563 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22564 if (!SWIG_IsOK(ecode2)) {
22565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22566 }
22567 arg2 = static_cast< long >(val2);
22568 if (arg1) (arg1)->m_keyCode = arg2;
22569
22570 resultobj = SWIG_Py_Void();
22571 return resultobj;
22572 fail:
22573 return NULL;
22574 }
22575
22576
22577 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22578 PyObject *resultobj = 0;
22579 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22580 long result;
22581 void *argp1 = 0 ;
22582 int res1 = 0 ;
22583 PyObject *swig_obj[1] ;
22584
22585 if (!args) SWIG_fail;
22586 swig_obj[0] = args;
22587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22588 if (!SWIG_IsOK(res1)) {
22589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22590 }
22591 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22592 result = (long) ((arg1)->m_keyCode);
22593 resultobj = SWIG_From_long(static_cast< long >(result));
22594 return resultobj;
22595 fail:
22596 return NULL;
22597 }
22598
22599
22600 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22601 PyObject *resultobj = 0;
22602 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22603 bool arg2 ;
22604 void *argp1 = 0 ;
22605 int res1 = 0 ;
22606 bool val2 ;
22607 int ecode2 = 0 ;
22608 PyObject *swig_obj[2] ;
22609
22610 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22612 if (!SWIG_IsOK(res1)) {
22613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22614 }
22615 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22616 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22617 if (!SWIG_IsOK(ecode2)) {
22618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22619 }
22620 arg2 = static_cast< bool >(val2);
22621 if (arg1) (arg1)->m_controlDown = arg2;
22622
22623 resultobj = SWIG_Py_Void();
22624 return resultobj;
22625 fail:
22626 return NULL;
22627 }
22628
22629
22630 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22631 PyObject *resultobj = 0;
22632 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22633 bool result;
22634 void *argp1 = 0 ;
22635 int res1 = 0 ;
22636 PyObject *swig_obj[1] ;
22637
22638 if (!args) SWIG_fail;
22639 swig_obj[0] = args;
22640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22641 if (!SWIG_IsOK(res1)) {
22642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22643 }
22644 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22645 result = (bool) ((arg1)->m_controlDown);
22646 {
22647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22648 }
22649 return resultobj;
22650 fail:
22651 return NULL;
22652 }
22653
22654
22655 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22656 PyObject *resultobj = 0;
22657 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22658 bool arg2 ;
22659 void *argp1 = 0 ;
22660 int res1 = 0 ;
22661 bool val2 ;
22662 int ecode2 = 0 ;
22663 PyObject *swig_obj[2] ;
22664
22665 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22667 if (!SWIG_IsOK(res1)) {
22668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22669 }
22670 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22671 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22672 if (!SWIG_IsOK(ecode2)) {
22673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22674 }
22675 arg2 = static_cast< bool >(val2);
22676 if (arg1) (arg1)->m_shiftDown = arg2;
22677
22678 resultobj = SWIG_Py_Void();
22679 return resultobj;
22680 fail:
22681 return NULL;
22682 }
22683
22684
22685 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22686 PyObject *resultobj = 0;
22687 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22688 bool result;
22689 void *argp1 = 0 ;
22690 int res1 = 0 ;
22691 PyObject *swig_obj[1] ;
22692
22693 if (!args) SWIG_fail;
22694 swig_obj[0] = args;
22695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22696 if (!SWIG_IsOK(res1)) {
22697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22698 }
22699 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22700 result = (bool) ((arg1)->m_shiftDown);
22701 {
22702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22703 }
22704 return resultobj;
22705 fail:
22706 return NULL;
22707 }
22708
22709
22710 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22711 PyObject *resultobj = 0;
22712 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22713 bool arg2 ;
22714 void *argp1 = 0 ;
22715 int res1 = 0 ;
22716 bool val2 ;
22717 int ecode2 = 0 ;
22718 PyObject *swig_obj[2] ;
22719
22720 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22722 if (!SWIG_IsOK(res1)) {
22723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22724 }
22725 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22726 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22727 if (!SWIG_IsOK(ecode2)) {
22728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22729 }
22730 arg2 = static_cast< bool >(val2);
22731 if (arg1) (arg1)->m_altDown = arg2;
22732
22733 resultobj = SWIG_Py_Void();
22734 return resultobj;
22735 fail:
22736 return NULL;
22737 }
22738
22739
22740 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22741 PyObject *resultobj = 0;
22742 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22743 bool result;
22744 void *argp1 = 0 ;
22745 int res1 = 0 ;
22746 PyObject *swig_obj[1] ;
22747
22748 if (!args) SWIG_fail;
22749 swig_obj[0] = args;
22750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22751 if (!SWIG_IsOK(res1)) {
22752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22753 }
22754 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22755 result = (bool) ((arg1)->m_altDown);
22756 {
22757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22758 }
22759 return resultobj;
22760 fail:
22761 return NULL;
22762 }
22763
22764
22765 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22766 PyObject *resultobj = 0;
22767 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22768 bool arg2 ;
22769 void *argp1 = 0 ;
22770 int res1 = 0 ;
22771 bool val2 ;
22772 int ecode2 = 0 ;
22773 PyObject *swig_obj[2] ;
22774
22775 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22777 if (!SWIG_IsOK(res1)) {
22778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22779 }
22780 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22781 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22782 if (!SWIG_IsOK(ecode2)) {
22783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22784 }
22785 arg2 = static_cast< bool >(val2);
22786 if (arg1) (arg1)->m_metaDown = arg2;
22787
22788 resultobj = SWIG_Py_Void();
22789 return resultobj;
22790 fail:
22791 return NULL;
22792 }
22793
22794
22795 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22796 PyObject *resultobj = 0;
22797 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22798 bool result;
22799 void *argp1 = 0 ;
22800 int res1 = 0 ;
22801 PyObject *swig_obj[1] ;
22802
22803 if (!args) SWIG_fail;
22804 swig_obj[0] = args;
22805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22806 if (!SWIG_IsOK(res1)) {
22807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22808 }
22809 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22810 result = (bool) ((arg1)->m_metaDown);
22811 {
22812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22813 }
22814 return resultobj;
22815 fail:
22816 return NULL;
22817 }
22818
22819
22820 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22821 PyObject *resultobj = 0;
22822 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22823 bool arg2 ;
22824 void *argp1 = 0 ;
22825 int res1 = 0 ;
22826 bool val2 ;
22827 int ecode2 = 0 ;
22828 PyObject *swig_obj[2] ;
22829
22830 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22832 if (!SWIG_IsOK(res1)) {
22833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22834 }
22835 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22836 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22837 if (!SWIG_IsOK(ecode2)) {
22838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22839 }
22840 arg2 = static_cast< bool >(val2);
22841 if (arg1) (arg1)->m_scanCode = arg2;
22842
22843 resultobj = SWIG_Py_Void();
22844 return resultobj;
22845 fail:
22846 return NULL;
22847 }
22848
22849
22850 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22851 PyObject *resultobj = 0;
22852 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22853 bool result;
22854 void *argp1 = 0 ;
22855 int res1 = 0 ;
22856 PyObject *swig_obj[1] ;
22857
22858 if (!args) SWIG_fail;
22859 swig_obj[0] = args;
22860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22861 if (!SWIG_IsOK(res1)) {
22862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22863 }
22864 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22865 result = (bool) ((arg1)->m_scanCode);
22866 {
22867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22868 }
22869 return resultobj;
22870 fail:
22871 return NULL;
22872 }
22873
22874
22875 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22876 PyObject *resultobj = 0;
22877 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22878 unsigned int arg2 ;
22879 void *argp1 = 0 ;
22880 int res1 = 0 ;
22881 unsigned int val2 ;
22882 int ecode2 = 0 ;
22883 PyObject *swig_obj[2] ;
22884
22885 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22887 if (!SWIG_IsOK(res1)) {
22888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22889 }
22890 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22891 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22892 if (!SWIG_IsOK(ecode2)) {
22893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22894 }
22895 arg2 = static_cast< unsigned int >(val2);
22896 if (arg1) (arg1)->m_rawCode = arg2;
22897
22898 resultobj = SWIG_Py_Void();
22899 return resultobj;
22900 fail:
22901 return NULL;
22902 }
22903
22904
22905 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22906 PyObject *resultobj = 0;
22907 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22908 unsigned int result;
22909 void *argp1 = 0 ;
22910 int res1 = 0 ;
22911 PyObject *swig_obj[1] ;
22912
22913 if (!args) SWIG_fail;
22914 swig_obj[0] = args;
22915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22916 if (!SWIG_IsOK(res1)) {
22917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22918 }
22919 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22920 result = (unsigned int) ((arg1)->m_rawCode);
22921 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22922 return resultobj;
22923 fail:
22924 return NULL;
22925 }
22926
22927
22928 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22929 PyObject *resultobj = 0;
22930 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22931 unsigned int arg2 ;
22932 void *argp1 = 0 ;
22933 int res1 = 0 ;
22934 unsigned int val2 ;
22935 int ecode2 = 0 ;
22936 PyObject *swig_obj[2] ;
22937
22938 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22940 if (!SWIG_IsOK(res1)) {
22941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22942 }
22943 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22944 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22945 if (!SWIG_IsOK(ecode2)) {
22946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22947 }
22948 arg2 = static_cast< unsigned int >(val2);
22949 if (arg1) (arg1)->m_rawFlags = arg2;
22950
22951 resultobj = SWIG_Py_Void();
22952 return resultobj;
22953 fail:
22954 return NULL;
22955 }
22956
22957
22958 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22959 PyObject *resultobj = 0;
22960 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22961 unsigned int result;
22962 void *argp1 = 0 ;
22963 int res1 = 0 ;
22964 PyObject *swig_obj[1] ;
22965
22966 if (!args) SWIG_fail;
22967 swig_obj[0] = args;
22968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22969 if (!SWIG_IsOK(res1)) {
22970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22971 }
22972 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22973 result = (unsigned int) ((arg1)->m_rawFlags);
22974 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22975 return resultobj;
22976 fail:
22977 return NULL;
22978 }
22979
22980
22981 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22982 PyObject *obj;
22983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22984 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22985 return SWIG_Py_Void();
22986 }
22987
22988 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22989 return SWIG_Python_InitShadowInstance(args);
22990 }
22991
22992 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22993 PyObject *resultobj = 0;
22994 wxSize const &arg1_defvalue = wxDefaultSize ;
22995 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22996 int arg2 = (int) 0 ;
22997 wxSizeEvent *result = 0 ;
22998 wxSize temp1 ;
22999 int val2 ;
23000 int ecode2 = 0 ;
23001 PyObject * obj0 = 0 ;
23002 PyObject * obj1 = 0 ;
23003 char * kwnames[] = {
23004 (char *) "sz",(char *) "winid", NULL
23005 };
23006
23007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23008 if (obj0) {
23009 {
23010 arg1 = &temp1;
23011 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23012 }
23013 }
23014 if (obj1) {
23015 ecode2 = SWIG_AsVal_int(obj1, &val2);
23016 if (!SWIG_IsOK(ecode2)) {
23017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23018 }
23019 arg2 = static_cast< int >(val2);
23020 }
23021 {
23022 PyThreadState* __tstate = wxPyBeginAllowThreads();
23023 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23024 wxPyEndAllowThreads(__tstate);
23025 if (PyErr_Occurred()) SWIG_fail;
23026 }
23027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23028 return resultobj;
23029 fail:
23030 return NULL;
23031 }
23032
23033
23034 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23035 PyObject *resultobj = 0;
23036 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23037 wxSize result;
23038 void *argp1 = 0 ;
23039 int res1 = 0 ;
23040 PyObject *swig_obj[1] ;
23041
23042 if (!args) SWIG_fail;
23043 swig_obj[0] = args;
23044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23045 if (!SWIG_IsOK(res1)) {
23046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23047 }
23048 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 result = ((wxSizeEvent const *)arg1)->GetSize();
23052 wxPyEndAllowThreads(__tstate);
23053 if (PyErr_Occurred()) SWIG_fail;
23054 }
23055 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23056 return resultobj;
23057 fail:
23058 return NULL;
23059 }
23060
23061
23062 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23063 PyObject *resultobj = 0;
23064 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23065 wxRect result;
23066 void *argp1 = 0 ;
23067 int res1 = 0 ;
23068 PyObject *swig_obj[1] ;
23069
23070 if (!args) SWIG_fail;
23071 swig_obj[0] = args;
23072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23073 if (!SWIG_IsOK(res1)) {
23074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23075 }
23076 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23077 {
23078 PyThreadState* __tstate = wxPyBeginAllowThreads();
23079 result = ((wxSizeEvent const *)arg1)->GetRect();
23080 wxPyEndAllowThreads(__tstate);
23081 if (PyErr_Occurred()) SWIG_fail;
23082 }
23083 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23084 return resultobj;
23085 fail:
23086 return NULL;
23087 }
23088
23089
23090 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23091 PyObject *resultobj = 0;
23092 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23093 wxRect arg2 ;
23094 void *argp1 = 0 ;
23095 int res1 = 0 ;
23096 void *argp2 ;
23097 int res2 = 0 ;
23098 PyObject * obj0 = 0 ;
23099 PyObject * obj1 = 0 ;
23100 char * kwnames[] = {
23101 (char *) "self",(char *) "rect", NULL
23102 };
23103
23104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23106 if (!SWIG_IsOK(res1)) {
23107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23108 }
23109 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23110 {
23111 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23112 if (!SWIG_IsOK(res2)) {
23113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23114 }
23115 if (!argp2) {
23116 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23117 } else {
23118 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23119 arg2 = *temp;
23120 if (SWIG_IsNewObj(res2)) delete temp;
23121 }
23122 }
23123 {
23124 PyThreadState* __tstate = wxPyBeginAllowThreads();
23125 (arg1)->SetRect(arg2);
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 resultobj = SWIG_Py_Void();
23130 return resultobj;
23131 fail:
23132 return NULL;
23133 }
23134
23135
23136 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23137 PyObject *resultobj = 0;
23138 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23139 wxSize arg2 ;
23140 void *argp1 = 0 ;
23141 int res1 = 0 ;
23142 void *argp2 ;
23143 int res2 = 0 ;
23144 PyObject * obj0 = 0 ;
23145 PyObject * obj1 = 0 ;
23146 char * kwnames[] = {
23147 (char *) "self",(char *) "size", NULL
23148 };
23149
23150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23152 if (!SWIG_IsOK(res1)) {
23153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23154 }
23155 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23156 {
23157 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23158 if (!SWIG_IsOK(res2)) {
23159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23160 }
23161 if (!argp2) {
23162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23163 } else {
23164 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23165 arg2 = *temp;
23166 if (SWIG_IsNewObj(res2)) delete temp;
23167 }
23168 }
23169 {
23170 PyThreadState* __tstate = wxPyBeginAllowThreads();
23171 wxSizeEvent_SetSize(arg1,arg2);
23172 wxPyEndAllowThreads(__tstate);
23173 if (PyErr_Occurred()) SWIG_fail;
23174 }
23175 resultobj = SWIG_Py_Void();
23176 return resultobj;
23177 fail:
23178 return NULL;
23179 }
23180
23181
23182 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23183 PyObject *resultobj = 0;
23184 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23185 wxSize *arg2 = (wxSize *) 0 ;
23186 void *argp1 = 0 ;
23187 int res1 = 0 ;
23188 void *argp2 = 0 ;
23189 int res2 = 0 ;
23190 PyObject *swig_obj[2] ;
23191
23192 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23194 if (!SWIG_IsOK(res1)) {
23195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23196 }
23197 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23198 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23199 if (!SWIG_IsOK(res2)) {
23200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23201 }
23202 arg2 = reinterpret_cast< wxSize * >(argp2);
23203 if (arg1) (arg1)->m_size = *arg2;
23204
23205 resultobj = SWIG_Py_Void();
23206 return resultobj;
23207 fail:
23208 return NULL;
23209 }
23210
23211
23212 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23213 PyObject *resultobj = 0;
23214 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23215 wxSize *result = 0 ;
23216 void *argp1 = 0 ;
23217 int res1 = 0 ;
23218 PyObject *swig_obj[1] ;
23219
23220 if (!args) SWIG_fail;
23221 swig_obj[0] = args;
23222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23223 if (!SWIG_IsOK(res1)) {
23224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23225 }
23226 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23227 result = (wxSize *)& ((arg1)->m_size);
23228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23229 return resultobj;
23230 fail:
23231 return NULL;
23232 }
23233
23234
23235 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23236 PyObject *resultobj = 0;
23237 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23238 wxRect *arg2 = (wxRect *) 0 ;
23239 void *argp1 = 0 ;
23240 int res1 = 0 ;
23241 void *argp2 = 0 ;
23242 int res2 = 0 ;
23243 PyObject *swig_obj[2] ;
23244
23245 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23247 if (!SWIG_IsOK(res1)) {
23248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23249 }
23250 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23251 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23252 if (!SWIG_IsOK(res2)) {
23253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23254 }
23255 arg2 = reinterpret_cast< wxRect * >(argp2);
23256 if (arg1) (arg1)->m_rect = *arg2;
23257
23258 resultobj = SWIG_Py_Void();
23259 return resultobj;
23260 fail:
23261 return NULL;
23262 }
23263
23264
23265 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23266 PyObject *resultobj = 0;
23267 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23268 wxRect *result = 0 ;
23269 void *argp1 = 0 ;
23270 int res1 = 0 ;
23271 PyObject *swig_obj[1] ;
23272
23273 if (!args) SWIG_fail;
23274 swig_obj[0] = args;
23275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23276 if (!SWIG_IsOK(res1)) {
23277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23278 }
23279 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23280 result = (wxRect *)& ((arg1)->m_rect);
23281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23282 return resultobj;
23283 fail:
23284 return NULL;
23285 }
23286
23287
23288 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23289 PyObject *obj;
23290 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23291 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23292 return SWIG_Py_Void();
23293 }
23294
23295 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23296 return SWIG_Python_InitShadowInstance(args);
23297 }
23298
23299 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23300 PyObject *resultobj = 0;
23301 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23302 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23303 int arg2 = (int) 0 ;
23304 wxMoveEvent *result = 0 ;
23305 wxPoint temp1 ;
23306 int val2 ;
23307 int ecode2 = 0 ;
23308 PyObject * obj0 = 0 ;
23309 PyObject * obj1 = 0 ;
23310 char * kwnames[] = {
23311 (char *) "pos",(char *) "winid", NULL
23312 };
23313
23314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23315 if (obj0) {
23316 {
23317 arg1 = &temp1;
23318 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23319 }
23320 }
23321 if (obj1) {
23322 ecode2 = SWIG_AsVal_int(obj1, &val2);
23323 if (!SWIG_IsOK(ecode2)) {
23324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23325 }
23326 arg2 = static_cast< int >(val2);
23327 }
23328 {
23329 PyThreadState* __tstate = wxPyBeginAllowThreads();
23330 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23331 wxPyEndAllowThreads(__tstate);
23332 if (PyErr_Occurred()) SWIG_fail;
23333 }
23334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23335 return resultobj;
23336 fail:
23337 return NULL;
23338 }
23339
23340
23341 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23342 PyObject *resultobj = 0;
23343 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23344 wxPoint result;
23345 void *argp1 = 0 ;
23346 int res1 = 0 ;
23347 PyObject *swig_obj[1] ;
23348
23349 if (!args) SWIG_fail;
23350 swig_obj[0] = args;
23351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23352 if (!SWIG_IsOK(res1)) {
23353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23354 }
23355 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23356 {
23357 PyThreadState* __tstate = wxPyBeginAllowThreads();
23358 result = ((wxMoveEvent const *)arg1)->GetPosition();
23359 wxPyEndAllowThreads(__tstate);
23360 if (PyErr_Occurred()) SWIG_fail;
23361 }
23362 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23363 return resultobj;
23364 fail:
23365 return NULL;
23366 }
23367
23368
23369 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23370 PyObject *resultobj = 0;
23371 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23372 wxRect result;
23373 void *argp1 = 0 ;
23374 int res1 = 0 ;
23375 PyObject *swig_obj[1] ;
23376
23377 if (!args) SWIG_fail;
23378 swig_obj[0] = args;
23379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23380 if (!SWIG_IsOK(res1)) {
23381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23382 }
23383 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23384 {
23385 PyThreadState* __tstate = wxPyBeginAllowThreads();
23386 result = ((wxMoveEvent const *)arg1)->GetRect();
23387 wxPyEndAllowThreads(__tstate);
23388 if (PyErr_Occurred()) SWIG_fail;
23389 }
23390 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23391 return resultobj;
23392 fail:
23393 return NULL;
23394 }
23395
23396
23397 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23398 PyObject *resultobj = 0;
23399 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23400 wxRect *arg2 = 0 ;
23401 void *argp1 = 0 ;
23402 int res1 = 0 ;
23403 wxRect temp2 ;
23404 PyObject * obj0 = 0 ;
23405 PyObject * obj1 = 0 ;
23406 char * kwnames[] = {
23407 (char *) "self",(char *) "rect", NULL
23408 };
23409
23410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23412 if (!SWIG_IsOK(res1)) {
23413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23414 }
23415 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23416 {
23417 arg2 = &temp2;
23418 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23419 }
23420 {
23421 PyThreadState* __tstate = wxPyBeginAllowThreads();
23422 (arg1)->SetRect((wxRect const &)*arg2);
23423 wxPyEndAllowThreads(__tstate);
23424 if (PyErr_Occurred()) SWIG_fail;
23425 }
23426 resultobj = SWIG_Py_Void();
23427 return resultobj;
23428 fail:
23429 return NULL;
23430 }
23431
23432
23433 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23434 PyObject *resultobj = 0;
23435 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23436 wxPoint *arg2 = 0 ;
23437 void *argp1 = 0 ;
23438 int res1 = 0 ;
23439 wxPoint temp2 ;
23440 PyObject * obj0 = 0 ;
23441 PyObject * obj1 = 0 ;
23442 char * kwnames[] = {
23443 (char *) "self",(char *) "pos", NULL
23444 };
23445
23446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23448 if (!SWIG_IsOK(res1)) {
23449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23450 }
23451 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23452 {
23453 arg2 = &temp2;
23454 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23455 }
23456 {
23457 PyThreadState* __tstate = wxPyBeginAllowThreads();
23458 (arg1)->SetPosition((wxPoint const &)*arg2);
23459 wxPyEndAllowThreads(__tstate);
23460 if (PyErr_Occurred()) SWIG_fail;
23461 }
23462 resultobj = SWIG_Py_Void();
23463 return resultobj;
23464 fail:
23465 return NULL;
23466 }
23467
23468
23469 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23470 PyObject *obj;
23471 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23472 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23473 return SWIG_Py_Void();
23474 }
23475
23476 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23477 return SWIG_Python_InitShadowInstance(args);
23478 }
23479
23480 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj = 0;
23482 int arg1 = (int) 0 ;
23483 wxPaintEvent *result = 0 ;
23484 int val1 ;
23485 int ecode1 = 0 ;
23486 PyObject * obj0 = 0 ;
23487 char * kwnames[] = {
23488 (char *) "Id", NULL
23489 };
23490
23491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23492 if (obj0) {
23493 ecode1 = SWIG_AsVal_int(obj0, &val1);
23494 if (!SWIG_IsOK(ecode1)) {
23495 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23496 }
23497 arg1 = static_cast< int >(val1);
23498 }
23499 {
23500 PyThreadState* __tstate = wxPyBeginAllowThreads();
23501 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23502 wxPyEndAllowThreads(__tstate);
23503 if (PyErr_Occurred()) SWIG_fail;
23504 }
23505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23506 return resultobj;
23507 fail:
23508 return NULL;
23509 }
23510
23511
23512 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23513 PyObject *obj;
23514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23515 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23516 return SWIG_Py_Void();
23517 }
23518
23519 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23520 return SWIG_Python_InitShadowInstance(args);
23521 }
23522
23523 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23524 PyObject *resultobj = 0;
23525 int arg1 = (int) 0 ;
23526 wxNcPaintEvent *result = 0 ;
23527 int val1 ;
23528 int ecode1 = 0 ;
23529 PyObject * obj0 = 0 ;
23530 char * kwnames[] = {
23531 (char *) "winid", NULL
23532 };
23533
23534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23535 if (obj0) {
23536 ecode1 = SWIG_AsVal_int(obj0, &val1);
23537 if (!SWIG_IsOK(ecode1)) {
23538 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23539 }
23540 arg1 = static_cast< int >(val1);
23541 }
23542 {
23543 PyThreadState* __tstate = wxPyBeginAllowThreads();
23544 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23545 wxPyEndAllowThreads(__tstate);
23546 if (PyErr_Occurred()) SWIG_fail;
23547 }
23548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23549 return resultobj;
23550 fail:
23551 return NULL;
23552 }
23553
23554
23555 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23556 PyObject *obj;
23557 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23558 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23559 return SWIG_Py_Void();
23560 }
23561
23562 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23563 return SWIG_Python_InitShadowInstance(args);
23564 }
23565
23566 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23567 PyObject *resultobj = 0;
23568 int arg1 = (int) 0 ;
23569 wxDC *arg2 = (wxDC *) NULL ;
23570 wxEraseEvent *result = 0 ;
23571 int val1 ;
23572 int ecode1 = 0 ;
23573 void *argp2 = 0 ;
23574 int res2 = 0 ;
23575 PyObject * obj0 = 0 ;
23576 PyObject * obj1 = 0 ;
23577 char * kwnames[] = {
23578 (char *) "Id",(char *) "dc", NULL
23579 };
23580
23581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23582 if (obj0) {
23583 ecode1 = SWIG_AsVal_int(obj0, &val1);
23584 if (!SWIG_IsOK(ecode1)) {
23585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23586 }
23587 arg1 = static_cast< int >(val1);
23588 }
23589 if (obj1) {
23590 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23591 if (!SWIG_IsOK(res2)) {
23592 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23593 }
23594 arg2 = reinterpret_cast< wxDC * >(argp2);
23595 }
23596 {
23597 PyThreadState* __tstate = wxPyBeginAllowThreads();
23598 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23599 wxPyEndAllowThreads(__tstate);
23600 if (PyErr_Occurred()) SWIG_fail;
23601 }
23602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23603 return resultobj;
23604 fail:
23605 return NULL;
23606 }
23607
23608
23609 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23610 PyObject *resultobj = 0;
23611 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23612 wxDC *result = 0 ;
23613 void *argp1 = 0 ;
23614 int res1 = 0 ;
23615 PyObject *swig_obj[1] ;
23616
23617 if (!args) SWIG_fail;
23618 swig_obj[0] = args;
23619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23620 if (!SWIG_IsOK(res1)) {
23621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23622 }
23623 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23624 {
23625 PyThreadState* __tstate = wxPyBeginAllowThreads();
23626 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23627 wxPyEndAllowThreads(__tstate);
23628 if (PyErr_Occurred()) SWIG_fail;
23629 }
23630 {
23631 resultobj = wxPyMake_wxObject(result, (bool)0);
23632 }
23633 return resultobj;
23634 fail:
23635 return NULL;
23636 }
23637
23638
23639 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23640 PyObject *obj;
23641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23642 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23643 return SWIG_Py_Void();
23644 }
23645
23646 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23647 return SWIG_Python_InitShadowInstance(args);
23648 }
23649
23650 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23651 PyObject *resultobj = 0;
23652 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23653 int arg2 = (int) 0 ;
23654 wxFocusEvent *result = 0 ;
23655 int val1 ;
23656 int ecode1 = 0 ;
23657 int val2 ;
23658 int ecode2 = 0 ;
23659 PyObject * obj0 = 0 ;
23660 PyObject * obj1 = 0 ;
23661 char * kwnames[] = {
23662 (char *) "type",(char *) "winid", NULL
23663 };
23664
23665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23666 if (obj0) {
23667 ecode1 = SWIG_AsVal_int(obj0, &val1);
23668 if (!SWIG_IsOK(ecode1)) {
23669 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23670 }
23671 arg1 = static_cast< wxEventType >(val1);
23672 }
23673 if (obj1) {
23674 ecode2 = SWIG_AsVal_int(obj1, &val2);
23675 if (!SWIG_IsOK(ecode2)) {
23676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23677 }
23678 arg2 = static_cast< int >(val2);
23679 }
23680 {
23681 PyThreadState* __tstate = wxPyBeginAllowThreads();
23682 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23683 wxPyEndAllowThreads(__tstate);
23684 if (PyErr_Occurred()) SWIG_fail;
23685 }
23686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23687 return resultobj;
23688 fail:
23689 return NULL;
23690 }
23691
23692
23693 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23694 PyObject *resultobj = 0;
23695 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23696 wxWindow *result = 0 ;
23697 void *argp1 = 0 ;
23698 int res1 = 0 ;
23699 PyObject *swig_obj[1] ;
23700
23701 if (!args) SWIG_fail;
23702 swig_obj[0] = args;
23703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23704 if (!SWIG_IsOK(res1)) {
23705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23706 }
23707 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23708 {
23709 PyThreadState* __tstate = wxPyBeginAllowThreads();
23710 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23711 wxPyEndAllowThreads(__tstate);
23712 if (PyErr_Occurred()) SWIG_fail;
23713 }
23714 {
23715 resultobj = wxPyMake_wxObject(result, (bool)0);
23716 }
23717 return resultobj;
23718 fail:
23719 return NULL;
23720 }
23721
23722
23723 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23724 PyObject *resultobj = 0;
23725 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23726 wxWindow *arg2 = (wxWindow *) 0 ;
23727 void *argp1 = 0 ;
23728 int res1 = 0 ;
23729 void *argp2 = 0 ;
23730 int res2 = 0 ;
23731 PyObject * obj0 = 0 ;
23732 PyObject * obj1 = 0 ;
23733 char * kwnames[] = {
23734 (char *) "self",(char *) "win", NULL
23735 };
23736
23737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23739 if (!SWIG_IsOK(res1)) {
23740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23741 }
23742 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23743 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23744 if (!SWIG_IsOK(res2)) {
23745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23746 }
23747 arg2 = reinterpret_cast< wxWindow * >(argp2);
23748 {
23749 PyThreadState* __tstate = wxPyBeginAllowThreads();
23750 (arg1)->SetWindow(arg2);
23751 wxPyEndAllowThreads(__tstate);
23752 if (PyErr_Occurred()) SWIG_fail;
23753 }
23754 resultobj = SWIG_Py_Void();
23755 return resultobj;
23756 fail:
23757 return NULL;
23758 }
23759
23760
23761 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23762 PyObject *obj;
23763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23764 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23765 return SWIG_Py_Void();
23766 }
23767
23768 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23769 return SWIG_Python_InitShadowInstance(args);
23770 }
23771
23772 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23773 PyObject *resultobj = 0;
23774 wxWindow *arg1 = (wxWindow *) NULL ;
23775 wxChildFocusEvent *result = 0 ;
23776 void *argp1 = 0 ;
23777 int res1 = 0 ;
23778 PyObject * obj0 = 0 ;
23779 char * kwnames[] = {
23780 (char *) "win", NULL
23781 };
23782
23783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23784 if (obj0) {
23785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23786 if (!SWIG_IsOK(res1)) {
23787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23788 }
23789 arg1 = reinterpret_cast< wxWindow * >(argp1);
23790 }
23791 {
23792 PyThreadState* __tstate = wxPyBeginAllowThreads();
23793 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23794 wxPyEndAllowThreads(__tstate);
23795 if (PyErr_Occurred()) SWIG_fail;
23796 }
23797 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23798 return resultobj;
23799 fail:
23800 return NULL;
23801 }
23802
23803
23804 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23805 PyObject *resultobj = 0;
23806 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23807 wxWindow *result = 0 ;
23808 void *argp1 = 0 ;
23809 int res1 = 0 ;
23810 PyObject *swig_obj[1] ;
23811
23812 if (!args) SWIG_fail;
23813 swig_obj[0] = args;
23814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23815 if (!SWIG_IsOK(res1)) {
23816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23817 }
23818 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23819 {
23820 PyThreadState* __tstate = wxPyBeginAllowThreads();
23821 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23822 wxPyEndAllowThreads(__tstate);
23823 if (PyErr_Occurred()) SWIG_fail;
23824 }
23825 {
23826 resultobj = wxPyMake_wxObject(result, (bool)0);
23827 }
23828 return resultobj;
23829 fail:
23830 return NULL;
23831 }
23832
23833
23834 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23835 PyObject *obj;
23836 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23837 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23838 return SWIG_Py_Void();
23839 }
23840
23841 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23842 return SWIG_Python_InitShadowInstance(args);
23843 }
23844
23845 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23846 PyObject *resultobj = 0;
23847 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23848 bool arg2 = (bool) true ;
23849 int arg3 = (int) 0 ;
23850 wxActivateEvent *result = 0 ;
23851 int val1 ;
23852 int ecode1 = 0 ;
23853 bool val2 ;
23854 int ecode2 = 0 ;
23855 int val3 ;
23856 int ecode3 = 0 ;
23857 PyObject * obj0 = 0 ;
23858 PyObject * obj1 = 0 ;
23859 PyObject * obj2 = 0 ;
23860 char * kwnames[] = {
23861 (char *) "type",(char *) "active",(char *) "Id", NULL
23862 };
23863
23864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23865 if (obj0) {
23866 ecode1 = SWIG_AsVal_int(obj0, &val1);
23867 if (!SWIG_IsOK(ecode1)) {
23868 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23869 }
23870 arg1 = static_cast< wxEventType >(val1);
23871 }
23872 if (obj1) {
23873 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23874 if (!SWIG_IsOK(ecode2)) {
23875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23876 }
23877 arg2 = static_cast< bool >(val2);
23878 }
23879 if (obj2) {
23880 ecode3 = SWIG_AsVal_int(obj2, &val3);
23881 if (!SWIG_IsOK(ecode3)) {
23882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23883 }
23884 arg3 = static_cast< int >(val3);
23885 }
23886 {
23887 PyThreadState* __tstate = wxPyBeginAllowThreads();
23888 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23889 wxPyEndAllowThreads(__tstate);
23890 if (PyErr_Occurred()) SWIG_fail;
23891 }
23892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23893 return resultobj;
23894 fail:
23895 return NULL;
23896 }
23897
23898
23899 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23900 PyObject *resultobj = 0;
23901 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23902 bool result;
23903 void *argp1 = 0 ;
23904 int res1 = 0 ;
23905 PyObject *swig_obj[1] ;
23906
23907 if (!args) SWIG_fail;
23908 swig_obj[0] = args;
23909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23910 if (!SWIG_IsOK(res1)) {
23911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23912 }
23913 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23914 {
23915 PyThreadState* __tstate = wxPyBeginAllowThreads();
23916 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23917 wxPyEndAllowThreads(__tstate);
23918 if (PyErr_Occurred()) SWIG_fail;
23919 }
23920 {
23921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23922 }
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23930 PyObject *obj;
23931 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23932 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23933 return SWIG_Py_Void();
23934 }
23935
23936 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23937 return SWIG_Python_InitShadowInstance(args);
23938 }
23939
23940 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23941 PyObject *resultobj = 0;
23942 int arg1 = (int) 0 ;
23943 wxInitDialogEvent *result = 0 ;
23944 int val1 ;
23945 int ecode1 = 0 ;
23946 PyObject * obj0 = 0 ;
23947 char * kwnames[] = {
23948 (char *) "Id", NULL
23949 };
23950
23951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23952 if (obj0) {
23953 ecode1 = SWIG_AsVal_int(obj0, &val1);
23954 if (!SWIG_IsOK(ecode1)) {
23955 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23956 }
23957 arg1 = static_cast< int >(val1);
23958 }
23959 {
23960 PyThreadState* __tstate = wxPyBeginAllowThreads();
23961 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23962 wxPyEndAllowThreads(__tstate);
23963 if (PyErr_Occurred()) SWIG_fail;
23964 }
23965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23966 return resultobj;
23967 fail:
23968 return NULL;
23969 }
23970
23971
23972 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23973 PyObject *obj;
23974 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23975 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23976 return SWIG_Py_Void();
23977 }
23978
23979 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23980 return SWIG_Python_InitShadowInstance(args);
23981 }
23982
23983 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23984 PyObject *resultobj = 0;
23985 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23986 int arg2 = (int) 0 ;
23987 wxMenu *arg3 = (wxMenu *) NULL ;
23988 wxMenuEvent *result = 0 ;
23989 int val1 ;
23990 int ecode1 = 0 ;
23991 int val2 ;
23992 int ecode2 = 0 ;
23993 void *argp3 = 0 ;
23994 int res3 = 0 ;
23995 PyObject * obj0 = 0 ;
23996 PyObject * obj1 = 0 ;
23997 PyObject * obj2 = 0 ;
23998 char * kwnames[] = {
23999 (char *) "type",(char *) "winid",(char *) "menu", NULL
24000 };
24001
24002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24003 if (obj0) {
24004 ecode1 = SWIG_AsVal_int(obj0, &val1);
24005 if (!SWIG_IsOK(ecode1)) {
24006 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24007 }
24008 arg1 = static_cast< wxEventType >(val1);
24009 }
24010 if (obj1) {
24011 ecode2 = SWIG_AsVal_int(obj1, &val2);
24012 if (!SWIG_IsOK(ecode2)) {
24013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24014 }
24015 arg2 = static_cast< int >(val2);
24016 }
24017 if (obj2) {
24018 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24019 if (!SWIG_IsOK(res3)) {
24020 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24021 }
24022 arg3 = reinterpret_cast< wxMenu * >(argp3);
24023 }
24024 {
24025 PyThreadState* __tstate = wxPyBeginAllowThreads();
24026 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24027 wxPyEndAllowThreads(__tstate);
24028 if (PyErr_Occurred()) SWIG_fail;
24029 }
24030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24031 return resultobj;
24032 fail:
24033 return NULL;
24034 }
24035
24036
24037 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24038 PyObject *resultobj = 0;
24039 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24040 int result;
24041 void *argp1 = 0 ;
24042 int res1 = 0 ;
24043 PyObject *swig_obj[1] ;
24044
24045 if (!args) SWIG_fail;
24046 swig_obj[0] = args;
24047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24048 if (!SWIG_IsOK(res1)) {
24049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24050 }
24051 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24052 {
24053 PyThreadState* __tstate = wxPyBeginAllowThreads();
24054 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24055 wxPyEndAllowThreads(__tstate);
24056 if (PyErr_Occurred()) SWIG_fail;
24057 }
24058 resultobj = SWIG_From_int(static_cast< int >(result));
24059 return resultobj;
24060 fail:
24061 return NULL;
24062 }
24063
24064
24065 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24066 PyObject *resultobj = 0;
24067 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24068 bool result;
24069 void *argp1 = 0 ;
24070 int res1 = 0 ;
24071 PyObject *swig_obj[1] ;
24072
24073 if (!args) SWIG_fail;
24074 swig_obj[0] = args;
24075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24076 if (!SWIG_IsOK(res1)) {
24077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24078 }
24079 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24080 {
24081 PyThreadState* __tstate = wxPyBeginAllowThreads();
24082 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24083 wxPyEndAllowThreads(__tstate);
24084 if (PyErr_Occurred()) SWIG_fail;
24085 }
24086 {
24087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24088 }
24089 return resultobj;
24090 fail:
24091 return NULL;
24092 }
24093
24094
24095 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24096 PyObject *resultobj = 0;
24097 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24098 wxMenu *result = 0 ;
24099 void *argp1 = 0 ;
24100 int res1 = 0 ;
24101 PyObject *swig_obj[1] ;
24102
24103 if (!args) SWIG_fail;
24104 swig_obj[0] = args;
24105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24106 if (!SWIG_IsOK(res1)) {
24107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24108 }
24109 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24110 {
24111 PyThreadState* __tstate = wxPyBeginAllowThreads();
24112 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24113 wxPyEndAllowThreads(__tstate);
24114 if (PyErr_Occurred()) SWIG_fail;
24115 }
24116 {
24117 resultobj = wxPyMake_wxObject(result, (bool)0);
24118 }
24119 return resultobj;
24120 fail:
24121 return NULL;
24122 }
24123
24124
24125 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24126 PyObject *obj;
24127 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24128 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24129 return SWIG_Py_Void();
24130 }
24131
24132 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24133 return SWIG_Python_InitShadowInstance(args);
24134 }
24135
24136 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24137 PyObject *resultobj = 0;
24138 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24139 int arg2 = (int) 0 ;
24140 wxCloseEvent *result = 0 ;
24141 int val1 ;
24142 int ecode1 = 0 ;
24143 int val2 ;
24144 int ecode2 = 0 ;
24145 PyObject * obj0 = 0 ;
24146 PyObject * obj1 = 0 ;
24147 char * kwnames[] = {
24148 (char *) "type",(char *) "winid", NULL
24149 };
24150
24151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24152 if (obj0) {
24153 ecode1 = SWIG_AsVal_int(obj0, &val1);
24154 if (!SWIG_IsOK(ecode1)) {
24155 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24156 }
24157 arg1 = static_cast< wxEventType >(val1);
24158 }
24159 if (obj1) {
24160 ecode2 = SWIG_AsVal_int(obj1, &val2);
24161 if (!SWIG_IsOK(ecode2)) {
24162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24163 }
24164 arg2 = static_cast< int >(val2);
24165 }
24166 {
24167 PyThreadState* __tstate = wxPyBeginAllowThreads();
24168 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24169 wxPyEndAllowThreads(__tstate);
24170 if (PyErr_Occurred()) SWIG_fail;
24171 }
24172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24173 return resultobj;
24174 fail:
24175 return NULL;
24176 }
24177
24178
24179 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24180 PyObject *resultobj = 0;
24181 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24182 bool arg2 ;
24183 void *argp1 = 0 ;
24184 int res1 = 0 ;
24185 bool val2 ;
24186 int ecode2 = 0 ;
24187 PyObject * obj0 = 0 ;
24188 PyObject * obj1 = 0 ;
24189 char * kwnames[] = {
24190 (char *) "self",(char *) "logOff", NULL
24191 };
24192
24193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24195 if (!SWIG_IsOK(res1)) {
24196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24197 }
24198 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24199 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24200 if (!SWIG_IsOK(ecode2)) {
24201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24202 }
24203 arg2 = static_cast< bool >(val2);
24204 {
24205 PyThreadState* __tstate = wxPyBeginAllowThreads();
24206 (arg1)->SetLoggingOff(arg2);
24207 wxPyEndAllowThreads(__tstate);
24208 if (PyErr_Occurred()) SWIG_fail;
24209 }
24210 resultobj = SWIG_Py_Void();
24211 return resultobj;
24212 fail:
24213 return NULL;
24214 }
24215
24216
24217 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24218 PyObject *resultobj = 0;
24219 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24220 bool result;
24221 void *argp1 = 0 ;
24222 int res1 = 0 ;
24223 PyObject *swig_obj[1] ;
24224
24225 if (!args) SWIG_fail;
24226 swig_obj[0] = args;
24227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24228 if (!SWIG_IsOK(res1)) {
24229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24230 }
24231 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24232 {
24233 PyThreadState* __tstate = wxPyBeginAllowThreads();
24234 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24235 wxPyEndAllowThreads(__tstate);
24236 if (PyErr_Occurred()) SWIG_fail;
24237 }
24238 {
24239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24240 }
24241 return resultobj;
24242 fail:
24243 return NULL;
24244 }
24245
24246
24247 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24248 PyObject *resultobj = 0;
24249 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24250 bool arg2 = (bool) true ;
24251 void *argp1 = 0 ;
24252 int res1 = 0 ;
24253 bool val2 ;
24254 int ecode2 = 0 ;
24255 PyObject * obj0 = 0 ;
24256 PyObject * obj1 = 0 ;
24257 char * kwnames[] = {
24258 (char *) "self",(char *) "veto", NULL
24259 };
24260
24261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24263 if (!SWIG_IsOK(res1)) {
24264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24265 }
24266 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24267 if (obj1) {
24268 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24269 if (!SWIG_IsOK(ecode2)) {
24270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24271 }
24272 arg2 = static_cast< bool >(val2);
24273 }
24274 {
24275 PyThreadState* __tstate = wxPyBeginAllowThreads();
24276 (arg1)->Veto(arg2);
24277 wxPyEndAllowThreads(__tstate);
24278 if (PyErr_Occurred()) SWIG_fail;
24279 }
24280 resultobj = SWIG_Py_Void();
24281 return resultobj;
24282 fail:
24283 return NULL;
24284 }
24285
24286
24287 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24288 PyObject *resultobj = 0;
24289 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24290 bool result;
24291 void *argp1 = 0 ;
24292 int res1 = 0 ;
24293 PyObject *swig_obj[1] ;
24294
24295 if (!args) SWIG_fail;
24296 swig_obj[0] = args;
24297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24298 if (!SWIG_IsOK(res1)) {
24299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24300 }
24301 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24302 {
24303 PyThreadState* __tstate = wxPyBeginAllowThreads();
24304 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24305 wxPyEndAllowThreads(__tstate);
24306 if (PyErr_Occurred()) SWIG_fail;
24307 }
24308 {
24309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24310 }
24311 return resultobj;
24312 fail:
24313 return NULL;
24314 }
24315
24316
24317 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24318 PyObject *resultobj = 0;
24319 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24320 bool arg2 ;
24321 void *argp1 = 0 ;
24322 int res1 = 0 ;
24323 bool val2 ;
24324 int ecode2 = 0 ;
24325 PyObject * obj0 = 0 ;
24326 PyObject * obj1 = 0 ;
24327 char * kwnames[] = {
24328 (char *) "self",(char *) "canVeto", NULL
24329 };
24330
24331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24333 if (!SWIG_IsOK(res1)) {
24334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24335 }
24336 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24337 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24338 if (!SWIG_IsOK(ecode2)) {
24339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24340 }
24341 arg2 = static_cast< bool >(val2);
24342 {
24343 PyThreadState* __tstate = wxPyBeginAllowThreads();
24344 (arg1)->SetCanVeto(arg2);
24345 wxPyEndAllowThreads(__tstate);
24346 if (PyErr_Occurred()) SWIG_fail;
24347 }
24348 resultobj = SWIG_Py_Void();
24349 return resultobj;
24350 fail:
24351 return NULL;
24352 }
24353
24354
24355 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24356 PyObject *resultobj = 0;
24357 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24358 bool result;
24359 void *argp1 = 0 ;
24360 int res1 = 0 ;
24361 PyObject *swig_obj[1] ;
24362
24363 if (!args) SWIG_fail;
24364 swig_obj[0] = args;
24365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24366 if (!SWIG_IsOK(res1)) {
24367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24368 }
24369 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24370 {
24371 PyThreadState* __tstate = wxPyBeginAllowThreads();
24372 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24373 wxPyEndAllowThreads(__tstate);
24374 if (PyErr_Occurred()) SWIG_fail;
24375 }
24376 {
24377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24378 }
24379 return resultobj;
24380 fail:
24381 return NULL;
24382 }
24383
24384
24385 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24386 PyObject *obj;
24387 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24388 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24389 return SWIG_Py_Void();
24390 }
24391
24392 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24393 return SWIG_Python_InitShadowInstance(args);
24394 }
24395
24396 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24397 PyObject *resultobj = 0;
24398 int arg1 = (int) 0 ;
24399 bool arg2 = (bool) false ;
24400 wxShowEvent *result = 0 ;
24401 int val1 ;
24402 int ecode1 = 0 ;
24403 bool val2 ;
24404 int ecode2 = 0 ;
24405 PyObject * obj0 = 0 ;
24406 PyObject * obj1 = 0 ;
24407 char * kwnames[] = {
24408 (char *) "winid",(char *) "show", NULL
24409 };
24410
24411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24412 if (obj0) {
24413 ecode1 = SWIG_AsVal_int(obj0, &val1);
24414 if (!SWIG_IsOK(ecode1)) {
24415 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24416 }
24417 arg1 = static_cast< int >(val1);
24418 }
24419 if (obj1) {
24420 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24421 if (!SWIG_IsOK(ecode2)) {
24422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24423 }
24424 arg2 = static_cast< bool >(val2);
24425 }
24426 {
24427 PyThreadState* __tstate = wxPyBeginAllowThreads();
24428 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24429 wxPyEndAllowThreads(__tstate);
24430 if (PyErr_Occurred()) SWIG_fail;
24431 }
24432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24433 return resultobj;
24434 fail:
24435 return NULL;
24436 }
24437
24438
24439 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24440 PyObject *resultobj = 0;
24441 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24442 bool arg2 ;
24443 void *argp1 = 0 ;
24444 int res1 = 0 ;
24445 bool val2 ;
24446 int ecode2 = 0 ;
24447 PyObject * obj0 = 0 ;
24448 PyObject * obj1 = 0 ;
24449 char * kwnames[] = {
24450 (char *) "self",(char *) "show", NULL
24451 };
24452
24453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24455 if (!SWIG_IsOK(res1)) {
24456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24457 }
24458 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24459 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24460 if (!SWIG_IsOK(ecode2)) {
24461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24462 }
24463 arg2 = static_cast< bool >(val2);
24464 {
24465 PyThreadState* __tstate = wxPyBeginAllowThreads();
24466 (arg1)->SetShow(arg2);
24467 wxPyEndAllowThreads(__tstate);
24468 if (PyErr_Occurred()) SWIG_fail;
24469 }
24470 resultobj = SWIG_Py_Void();
24471 return resultobj;
24472 fail:
24473 return NULL;
24474 }
24475
24476
24477 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24478 PyObject *resultobj = 0;
24479 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24480 bool result;
24481 void *argp1 = 0 ;
24482 int res1 = 0 ;
24483 PyObject *swig_obj[1] ;
24484
24485 if (!args) SWIG_fail;
24486 swig_obj[0] = args;
24487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24488 if (!SWIG_IsOK(res1)) {
24489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24490 }
24491 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24492 {
24493 PyThreadState* __tstate = wxPyBeginAllowThreads();
24494 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24495 wxPyEndAllowThreads(__tstate);
24496 if (PyErr_Occurred()) SWIG_fail;
24497 }
24498 {
24499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24500 }
24501 return resultobj;
24502 fail:
24503 return NULL;
24504 }
24505
24506
24507 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24508 PyObject *obj;
24509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24510 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24511 return SWIG_Py_Void();
24512 }
24513
24514 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24515 return SWIG_Python_InitShadowInstance(args);
24516 }
24517
24518 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24519 PyObject *resultobj = 0;
24520 int arg1 = (int) 0 ;
24521 bool arg2 = (bool) true ;
24522 wxIconizeEvent *result = 0 ;
24523 int val1 ;
24524 int ecode1 = 0 ;
24525 bool val2 ;
24526 int ecode2 = 0 ;
24527 PyObject * obj0 = 0 ;
24528 PyObject * obj1 = 0 ;
24529 char * kwnames[] = {
24530 (char *) "id",(char *) "iconized", NULL
24531 };
24532
24533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24534 if (obj0) {
24535 ecode1 = SWIG_AsVal_int(obj0, &val1);
24536 if (!SWIG_IsOK(ecode1)) {
24537 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24538 }
24539 arg1 = static_cast< int >(val1);
24540 }
24541 if (obj1) {
24542 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24543 if (!SWIG_IsOK(ecode2)) {
24544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24545 }
24546 arg2 = static_cast< bool >(val2);
24547 }
24548 {
24549 PyThreadState* __tstate = wxPyBeginAllowThreads();
24550 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24551 wxPyEndAllowThreads(__tstate);
24552 if (PyErr_Occurred()) SWIG_fail;
24553 }
24554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24555 return resultobj;
24556 fail:
24557 return NULL;
24558 }
24559
24560
24561 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24562 PyObject *resultobj = 0;
24563 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24564 bool result;
24565 void *argp1 = 0 ;
24566 int res1 = 0 ;
24567 PyObject *swig_obj[1] ;
24568
24569 if (!args) SWIG_fail;
24570 swig_obj[0] = args;
24571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24572 if (!SWIG_IsOK(res1)) {
24573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24574 }
24575 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24576 {
24577 PyThreadState* __tstate = wxPyBeginAllowThreads();
24578 result = (bool)(arg1)->Iconized();
24579 wxPyEndAllowThreads(__tstate);
24580 if (PyErr_Occurred()) SWIG_fail;
24581 }
24582 {
24583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24584 }
24585 return resultobj;
24586 fail:
24587 return NULL;
24588 }
24589
24590
24591 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24592 PyObject *obj;
24593 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24594 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24595 return SWIG_Py_Void();
24596 }
24597
24598 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24599 return SWIG_Python_InitShadowInstance(args);
24600 }
24601
24602 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24603 PyObject *resultobj = 0;
24604 int arg1 = (int) 0 ;
24605 wxMaximizeEvent *result = 0 ;
24606 int val1 ;
24607 int ecode1 = 0 ;
24608 PyObject * obj0 = 0 ;
24609 char * kwnames[] = {
24610 (char *) "id", NULL
24611 };
24612
24613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24614 if (obj0) {
24615 ecode1 = SWIG_AsVal_int(obj0, &val1);
24616 if (!SWIG_IsOK(ecode1)) {
24617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24618 }
24619 arg1 = static_cast< int >(val1);
24620 }
24621 {
24622 PyThreadState* __tstate = wxPyBeginAllowThreads();
24623 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24624 wxPyEndAllowThreads(__tstate);
24625 if (PyErr_Occurred()) SWIG_fail;
24626 }
24627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24628 return resultobj;
24629 fail:
24630 return NULL;
24631 }
24632
24633
24634 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24635 PyObject *obj;
24636 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24637 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24638 return SWIG_Py_Void();
24639 }
24640
24641 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24642 return SWIG_Python_InitShadowInstance(args);
24643 }
24644
24645 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24646 PyObject *resultobj = 0;
24647 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24648 wxPoint result;
24649 void *argp1 = 0 ;
24650 int res1 = 0 ;
24651 PyObject *swig_obj[1] ;
24652
24653 if (!args) SWIG_fail;
24654 swig_obj[0] = args;
24655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24656 if (!SWIG_IsOK(res1)) {
24657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24658 }
24659 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24660 {
24661 PyThreadState* __tstate = wxPyBeginAllowThreads();
24662 result = (arg1)->GetPosition();
24663 wxPyEndAllowThreads(__tstate);
24664 if (PyErr_Occurred()) SWIG_fail;
24665 }
24666 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24667 return resultobj;
24668 fail:
24669 return NULL;
24670 }
24671
24672
24673 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24674 PyObject *resultobj = 0;
24675 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24676 int result;
24677 void *argp1 = 0 ;
24678 int res1 = 0 ;
24679 PyObject *swig_obj[1] ;
24680
24681 if (!args) SWIG_fail;
24682 swig_obj[0] = args;
24683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24684 if (!SWIG_IsOK(res1)) {
24685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24686 }
24687 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24688 {
24689 PyThreadState* __tstate = wxPyBeginAllowThreads();
24690 result = (int)(arg1)->GetNumberOfFiles();
24691 wxPyEndAllowThreads(__tstate);
24692 if (PyErr_Occurred()) SWIG_fail;
24693 }
24694 resultobj = SWIG_From_int(static_cast< int >(result));
24695 return resultobj;
24696 fail:
24697 return NULL;
24698 }
24699
24700
24701 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24702 PyObject *resultobj = 0;
24703 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24704 PyObject *result = 0 ;
24705 void *argp1 = 0 ;
24706 int res1 = 0 ;
24707 PyObject *swig_obj[1] ;
24708
24709 if (!args) SWIG_fail;
24710 swig_obj[0] = args;
24711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24712 if (!SWIG_IsOK(res1)) {
24713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24714 }
24715 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24716 {
24717 PyThreadState* __tstate = wxPyBeginAllowThreads();
24718 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24719 wxPyEndAllowThreads(__tstate);
24720 if (PyErr_Occurred()) SWIG_fail;
24721 }
24722 resultobj = result;
24723 return resultobj;
24724 fail:
24725 return NULL;
24726 }
24727
24728
24729 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24730 PyObject *obj;
24731 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24732 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24733 return SWIG_Py_Void();
24734 }
24735
24736 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24737 PyObject *resultobj = 0;
24738 int arg1 = (int) 0 ;
24739 wxUpdateUIEvent *result = 0 ;
24740 int val1 ;
24741 int ecode1 = 0 ;
24742 PyObject * obj0 = 0 ;
24743 char * kwnames[] = {
24744 (char *) "commandId", NULL
24745 };
24746
24747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24748 if (obj0) {
24749 ecode1 = SWIG_AsVal_int(obj0, &val1);
24750 if (!SWIG_IsOK(ecode1)) {
24751 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24752 }
24753 arg1 = static_cast< int >(val1);
24754 }
24755 {
24756 PyThreadState* __tstate = wxPyBeginAllowThreads();
24757 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24758 wxPyEndAllowThreads(__tstate);
24759 if (PyErr_Occurred()) SWIG_fail;
24760 }
24761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24762 return resultobj;
24763 fail:
24764 return NULL;
24765 }
24766
24767
24768 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24769 PyObject *resultobj = 0;
24770 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24771 bool result;
24772 void *argp1 = 0 ;
24773 int res1 = 0 ;
24774 PyObject *swig_obj[1] ;
24775
24776 if (!args) SWIG_fail;
24777 swig_obj[0] = args;
24778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24779 if (!SWIG_IsOK(res1)) {
24780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24781 }
24782 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24783 {
24784 PyThreadState* __tstate = wxPyBeginAllowThreads();
24785 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24786 wxPyEndAllowThreads(__tstate);
24787 if (PyErr_Occurred()) SWIG_fail;
24788 }
24789 {
24790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24791 }
24792 return resultobj;
24793 fail:
24794 return NULL;
24795 }
24796
24797
24798 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24799 PyObject *resultobj = 0;
24800 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24801 bool result;
24802 void *argp1 = 0 ;
24803 int res1 = 0 ;
24804 PyObject *swig_obj[1] ;
24805
24806 if (!args) SWIG_fail;
24807 swig_obj[0] = args;
24808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24809 if (!SWIG_IsOK(res1)) {
24810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24811 }
24812 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24813 {
24814 PyThreadState* __tstate = wxPyBeginAllowThreads();
24815 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24816 wxPyEndAllowThreads(__tstate);
24817 if (PyErr_Occurred()) SWIG_fail;
24818 }
24819 {
24820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24821 }
24822 return resultobj;
24823 fail:
24824 return NULL;
24825 }
24826
24827
24828 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24829 PyObject *resultobj = 0;
24830 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24831 bool result;
24832 void *argp1 = 0 ;
24833 int res1 = 0 ;
24834 PyObject *swig_obj[1] ;
24835
24836 if (!args) SWIG_fail;
24837 swig_obj[0] = args;
24838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24839 if (!SWIG_IsOK(res1)) {
24840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24841 }
24842 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24843 {
24844 PyThreadState* __tstate = wxPyBeginAllowThreads();
24845 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24846 wxPyEndAllowThreads(__tstate);
24847 if (PyErr_Occurred()) SWIG_fail;
24848 }
24849 {
24850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24851 }
24852 return resultobj;
24853 fail:
24854 return NULL;
24855 }
24856
24857
24858 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24859 PyObject *resultobj = 0;
24860 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24861 wxString result;
24862 void *argp1 = 0 ;
24863 int res1 = 0 ;
24864 PyObject *swig_obj[1] ;
24865
24866 if (!args) SWIG_fail;
24867 swig_obj[0] = args;
24868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24869 if (!SWIG_IsOK(res1)) {
24870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24871 }
24872 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24873 {
24874 PyThreadState* __tstate = wxPyBeginAllowThreads();
24875 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24876 wxPyEndAllowThreads(__tstate);
24877 if (PyErr_Occurred()) SWIG_fail;
24878 }
24879 {
24880 #if wxUSE_UNICODE
24881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24882 #else
24883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24884 #endif
24885 }
24886 return resultobj;
24887 fail:
24888 return NULL;
24889 }
24890
24891
24892 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24893 PyObject *resultobj = 0;
24894 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24895 bool result;
24896 void *argp1 = 0 ;
24897 int res1 = 0 ;
24898 PyObject *swig_obj[1] ;
24899
24900 if (!args) SWIG_fail;
24901 swig_obj[0] = args;
24902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24903 if (!SWIG_IsOK(res1)) {
24904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24905 }
24906 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24907 {
24908 PyThreadState* __tstate = wxPyBeginAllowThreads();
24909 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24910 wxPyEndAllowThreads(__tstate);
24911 if (PyErr_Occurred()) SWIG_fail;
24912 }
24913 {
24914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24915 }
24916 return resultobj;
24917 fail:
24918 return NULL;
24919 }
24920
24921
24922 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24923 PyObject *resultobj = 0;
24924 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24925 bool result;
24926 void *argp1 = 0 ;
24927 int res1 = 0 ;
24928 PyObject *swig_obj[1] ;
24929
24930 if (!args) SWIG_fail;
24931 swig_obj[0] = args;
24932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24933 if (!SWIG_IsOK(res1)) {
24934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24935 }
24936 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24937 {
24938 PyThreadState* __tstate = wxPyBeginAllowThreads();
24939 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24940 wxPyEndAllowThreads(__tstate);
24941 if (PyErr_Occurred()) SWIG_fail;
24942 }
24943 {
24944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24945 }
24946 return resultobj;
24947 fail:
24948 return NULL;
24949 }
24950
24951
24952 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24953 PyObject *resultobj = 0;
24954 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24955 bool result;
24956 void *argp1 = 0 ;
24957 int res1 = 0 ;
24958 PyObject *swig_obj[1] ;
24959
24960 if (!args) SWIG_fail;
24961 swig_obj[0] = args;
24962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24963 if (!SWIG_IsOK(res1)) {
24964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24965 }
24966 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24967 {
24968 PyThreadState* __tstate = wxPyBeginAllowThreads();
24969 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24970 wxPyEndAllowThreads(__tstate);
24971 if (PyErr_Occurred()) SWIG_fail;
24972 }
24973 {
24974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24975 }
24976 return resultobj;
24977 fail:
24978 return NULL;
24979 }
24980
24981
24982 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24983 PyObject *resultobj = 0;
24984 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24985 bool result;
24986 void *argp1 = 0 ;
24987 int res1 = 0 ;
24988 PyObject *swig_obj[1] ;
24989
24990 if (!args) SWIG_fail;
24991 swig_obj[0] = args;
24992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24993 if (!SWIG_IsOK(res1)) {
24994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24995 }
24996 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24997 {
24998 PyThreadState* __tstate = wxPyBeginAllowThreads();
24999 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25000 wxPyEndAllowThreads(__tstate);
25001 if (PyErr_Occurred()) SWIG_fail;
25002 }
25003 {
25004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25005 }
25006 return resultobj;
25007 fail:
25008 return NULL;
25009 }
25010
25011
25012 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25013 PyObject *resultobj = 0;
25014 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25015 bool arg2 ;
25016 void *argp1 = 0 ;
25017 int res1 = 0 ;
25018 bool val2 ;
25019 int ecode2 = 0 ;
25020 PyObject * obj0 = 0 ;
25021 PyObject * obj1 = 0 ;
25022 char * kwnames[] = {
25023 (char *) "self",(char *) "check", NULL
25024 };
25025
25026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25028 if (!SWIG_IsOK(res1)) {
25029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25030 }
25031 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25032 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25033 if (!SWIG_IsOK(ecode2)) {
25034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25035 }
25036 arg2 = static_cast< bool >(val2);
25037 {
25038 PyThreadState* __tstate = wxPyBeginAllowThreads();
25039 (arg1)->Check(arg2);
25040 wxPyEndAllowThreads(__tstate);
25041 if (PyErr_Occurred()) SWIG_fail;
25042 }
25043 resultobj = SWIG_Py_Void();
25044 return resultobj;
25045 fail:
25046 return NULL;
25047 }
25048
25049
25050 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25051 PyObject *resultobj = 0;
25052 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25053 bool arg2 ;
25054 void *argp1 = 0 ;
25055 int res1 = 0 ;
25056 bool val2 ;
25057 int ecode2 = 0 ;
25058 PyObject * obj0 = 0 ;
25059 PyObject * obj1 = 0 ;
25060 char * kwnames[] = {
25061 (char *) "self",(char *) "enable", NULL
25062 };
25063
25064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25066 if (!SWIG_IsOK(res1)) {
25067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25068 }
25069 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25070 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25071 if (!SWIG_IsOK(ecode2)) {
25072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25073 }
25074 arg2 = static_cast< bool >(val2);
25075 {
25076 PyThreadState* __tstate = wxPyBeginAllowThreads();
25077 (arg1)->Enable(arg2);
25078 wxPyEndAllowThreads(__tstate);
25079 if (PyErr_Occurred()) SWIG_fail;
25080 }
25081 resultobj = SWIG_Py_Void();
25082 return resultobj;
25083 fail:
25084 return NULL;
25085 }
25086
25087
25088 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25089 PyObject *resultobj = 0;
25090 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25091 bool arg2 ;
25092 void *argp1 = 0 ;
25093 int res1 = 0 ;
25094 bool val2 ;
25095 int ecode2 = 0 ;
25096 PyObject * obj0 = 0 ;
25097 PyObject * obj1 = 0 ;
25098 char * kwnames[] = {
25099 (char *) "self",(char *) "show", NULL
25100 };
25101
25102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25104 if (!SWIG_IsOK(res1)) {
25105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25106 }
25107 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25108 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25109 if (!SWIG_IsOK(ecode2)) {
25110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25111 }
25112 arg2 = static_cast< bool >(val2);
25113 {
25114 PyThreadState* __tstate = wxPyBeginAllowThreads();
25115 (arg1)->Show(arg2);
25116 wxPyEndAllowThreads(__tstate);
25117 if (PyErr_Occurred()) SWIG_fail;
25118 }
25119 resultobj = SWIG_Py_Void();
25120 return resultobj;
25121 fail:
25122 return NULL;
25123 }
25124
25125
25126 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25127 PyObject *resultobj = 0;
25128 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25129 wxString *arg2 = 0 ;
25130 void *argp1 = 0 ;
25131 int res1 = 0 ;
25132 bool temp2 = false ;
25133 PyObject * obj0 = 0 ;
25134 PyObject * obj1 = 0 ;
25135 char * kwnames[] = {
25136 (char *) "self",(char *) "text", NULL
25137 };
25138
25139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25141 if (!SWIG_IsOK(res1)) {
25142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25143 }
25144 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25145 {
25146 arg2 = wxString_in_helper(obj1);
25147 if (arg2 == NULL) SWIG_fail;
25148 temp2 = true;
25149 }
25150 {
25151 PyThreadState* __tstate = wxPyBeginAllowThreads();
25152 (arg1)->SetText((wxString const &)*arg2);
25153 wxPyEndAllowThreads(__tstate);
25154 if (PyErr_Occurred()) SWIG_fail;
25155 }
25156 resultobj = SWIG_Py_Void();
25157 {
25158 if (temp2)
25159 delete arg2;
25160 }
25161 return resultobj;
25162 fail:
25163 {
25164 if (temp2)
25165 delete arg2;
25166 }
25167 return NULL;
25168 }
25169
25170
25171 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25172 PyObject *resultobj = 0;
25173 long arg1 ;
25174 long val1 ;
25175 int ecode1 = 0 ;
25176 PyObject * obj0 = 0 ;
25177 char * kwnames[] = {
25178 (char *) "updateInterval", NULL
25179 };
25180
25181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25182 ecode1 = SWIG_AsVal_long(obj0, &val1);
25183 if (!SWIG_IsOK(ecode1)) {
25184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25185 }
25186 arg1 = static_cast< long >(val1);
25187 {
25188 PyThreadState* __tstate = wxPyBeginAllowThreads();
25189 wxUpdateUIEvent::SetUpdateInterval(arg1);
25190 wxPyEndAllowThreads(__tstate);
25191 if (PyErr_Occurred()) SWIG_fail;
25192 }
25193 resultobj = SWIG_Py_Void();
25194 return resultobj;
25195 fail:
25196 return NULL;
25197 }
25198
25199
25200 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25201 PyObject *resultobj = 0;
25202 long result;
25203
25204 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25205 {
25206 PyThreadState* __tstate = wxPyBeginAllowThreads();
25207 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25208 wxPyEndAllowThreads(__tstate);
25209 if (PyErr_Occurred()) SWIG_fail;
25210 }
25211 resultobj = SWIG_From_long(static_cast< long >(result));
25212 return resultobj;
25213 fail:
25214 return NULL;
25215 }
25216
25217
25218 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25219 PyObject *resultobj = 0;
25220 wxWindow *arg1 = (wxWindow *) 0 ;
25221 bool result;
25222 void *argp1 = 0 ;
25223 int res1 = 0 ;
25224 PyObject * obj0 = 0 ;
25225 char * kwnames[] = {
25226 (char *) "win", NULL
25227 };
25228
25229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25231 if (!SWIG_IsOK(res1)) {
25232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25233 }
25234 arg1 = reinterpret_cast< wxWindow * >(argp1);
25235 {
25236 PyThreadState* __tstate = wxPyBeginAllowThreads();
25237 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25238 wxPyEndAllowThreads(__tstate);
25239 if (PyErr_Occurred()) SWIG_fail;
25240 }
25241 {
25242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25243 }
25244 return resultobj;
25245 fail:
25246 return NULL;
25247 }
25248
25249
25250 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25251 PyObject *resultobj = 0;
25252
25253 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25254 {
25255 PyThreadState* __tstate = wxPyBeginAllowThreads();
25256 wxUpdateUIEvent::ResetUpdateTime();
25257 wxPyEndAllowThreads(__tstate);
25258 if (PyErr_Occurred()) SWIG_fail;
25259 }
25260 resultobj = SWIG_Py_Void();
25261 return resultobj;
25262 fail:
25263 return NULL;
25264 }
25265
25266
25267 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25268 PyObject *resultobj = 0;
25269 wxUpdateUIMode arg1 ;
25270 int val1 ;
25271 int ecode1 = 0 ;
25272 PyObject * obj0 = 0 ;
25273 char * kwnames[] = {
25274 (char *) "mode", NULL
25275 };
25276
25277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25278 ecode1 = SWIG_AsVal_int(obj0, &val1);
25279 if (!SWIG_IsOK(ecode1)) {
25280 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25281 }
25282 arg1 = static_cast< wxUpdateUIMode >(val1);
25283 {
25284 PyThreadState* __tstate = wxPyBeginAllowThreads();
25285 wxUpdateUIEvent::SetMode(arg1);
25286 wxPyEndAllowThreads(__tstate);
25287 if (PyErr_Occurred()) SWIG_fail;
25288 }
25289 resultobj = SWIG_Py_Void();
25290 return resultobj;
25291 fail:
25292 return NULL;
25293 }
25294
25295
25296 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25297 PyObject *resultobj = 0;
25298 wxUpdateUIMode result;
25299
25300 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25301 {
25302 PyThreadState* __tstate = wxPyBeginAllowThreads();
25303 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25304 wxPyEndAllowThreads(__tstate);
25305 if (PyErr_Occurred()) SWIG_fail;
25306 }
25307 resultobj = SWIG_From_int(static_cast< int >(result));
25308 return resultobj;
25309 fail:
25310 return NULL;
25311 }
25312
25313
25314 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25315 PyObject *obj;
25316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25317 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25318 return SWIG_Py_Void();
25319 }
25320
25321 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25322 return SWIG_Python_InitShadowInstance(args);
25323 }
25324
25325 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25326 PyObject *resultobj = 0;
25327 wxSysColourChangedEvent *result = 0 ;
25328
25329 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25330 {
25331 PyThreadState* __tstate = wxPyBeginAllowThreads();
25332 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25333 wxPyEndAllowThreads(__tstate);
25334 if (PyErr_Occurred()) SWIG_fail;
25335 }
25336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25337 return resultobj;
25338 fail:
25339 return NULL;
25340 }
25341
25342
25343 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25344 PyObject *obj;
25345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25346 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25347 return SWIG_Py_Void();
25348 }
25349
25350 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25351 return SWIG_Python_InitShadowInstance(args);
25352 }
25353
25354 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25355 PyObject *resultobj = 0;
25356 int arg1 = (int) 0 ;
25357 wxWindow *arg2 = (wxWindow *) NULL ;
25358 wxMouseCaptureChangedEvent *result = 0 ;
25359 int val1 ;
25360 int ecode1 = 0 ;
25361 void *argp2 = 0 ;
25362 int res2 = 0 ;
25363 PyObject * obj0 = 0 ;
25364 PyObject * obj1 = 0 ;
25365 char * kwnames[] = {
25366 (char *) "winid",(char *) "gainedCapture", NULL
25367 };
25368
25369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25370 if (obj0) {
25371 ecode1 = SWIG_AsVal_int(obj0, &val1);
25372 if (!SWIG_IsOK(ecode1)) {
25373 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25374 }
25375 arg1 = static_cast< int >(val1);
25376 }
25377 if (obj1) {
25378 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25379 if (!SWIG_IsOK(res2)) {
25380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25381 }
25382 arg2 = reinterpret_cast< wxWindow * >(argp2);
25383 }
25384 {
25385 PyThreadState* __tstate = wxPyBeginAllowThreads();
25386 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25387 wxPyEndAllowThreads(__tstate);
25388 if (PyErr_Occurred()) SWIG_fail;
25389 }
25390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25391 return resultobj;
25392 fail:
25393 return NULL;
25394 }
25395
25396
25397 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25398 PyObject *resultobj = 0;
25399 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25400 wxWindow *result = 0 ;
25401 void *argp1 = 0 ;
25402 int res1 = 0 ;
25403 PyObject *swig_obj[1] ;
25404
25405 if (!args) SWIG_fail;
25406 swig_obj[0] = args;
25407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25408 if (!SWIG_IsOK(res1)) {
25409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25410 }
25411 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25412 {
25413 PyThreadState* __tstate = wxPyBeginAllowThreads();
25414 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25415 wxPyEndAllowThreads(__tstate);
25416 if (PyErr_Occurred()) SWIG_fail;
25417 }
25418 {
25419 resultobj = wxPyMake_wxObject(result, (bool)0);
25420 }
25421 return resultobj;
25422 fail:
25423 return NULL;
25424 }
25425
25426
25427 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25428 PyObject *obj;
25429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25430 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25431 return SWIG_Py_Void();
25432 }
25433
25434 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25435 return SWIG_Python_InitShadowInstance(args);
25436 }
25437
25438 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25439 PyObject *resultobj = 0;
25440 wxDisplayChangedEvent *result = 0 ;
25441
25442 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25443 {
25444 PyThreadState* __tstate = wxPyBeginAllowThreads();
25445 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25446 wxPyEndAllowThreads(__tstate);
25447 if (PyErr_Occurred()) SWIG_fail;
25448 }
25449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25450 return resultobj;
25451 fail:
25452 return NULL;
25453 }
25454
25455
25456 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25457 PyObject *obj;
25458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25459 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25460 return SWIG_Py_Void();
25461 }
25462
25463 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25464 return SWIG_Python_InitShadowInstance(args);
25465 }
25466
25467 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25468 PyObject *resultobj = 0;
25469 int arg1 = (int) 0 ;
25470 wxPaletteChangedEvent *result = 0 ;
25471 int val1 ;
25472 int ecode1 = 0 ;
25473 PyObject * obj0 = 0 ;
25474 char * kwnames[] = {
25475 (char *) "id", NULL
25476 };
25477
25478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25479 if (obj0) {
25480 ecode1 = SWIG_AsVal_int(obj0, &val1);
25481 if (!SWIG_IsOK(ecode1)) {
25482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25483 }
25484 arg1 = static_cast< int >(val1);
25485 }
25486 {
25487 PyThreadState* __tstate = wxPyBeginAllowThreads();
25488 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25489 wxPyEndAllowThreads(__tstate);
25490 if (PyErr_Occurred()) SWIG_fail;
25491 }
25492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25493 return resultobj;
25494 fail:
25495 return NULL;
25496 }
25497
25498
25499 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25500 PyObject *resultobj = 0;
25501 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25502 wxWindow *arg2 = (wxWindow *) 0 ;
25503 void *argp1 = 0 ;
25504 int res1 = 0 ;
25505 void *argp2 = 0 ;
25506 int res2 = 0 ;
25507 PyObject * obj0 = 0 ;
25508 PyObject * obj1 = 0 ;
25509 char * kwnames[] = {
25510 (char *) "self",(char *) "win", NULL
25511 };
25512
25513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25515 if (!SWIG_IsOK(res1)) {
25516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25517 }
25518 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25519 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25520 if (!SWIG_IsOK(res2)) {
25521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25522 }
25523 arg2 = reinterpret_cast< wxWindow * >(argp2);
25524 {
25525 PyThreadState* __tstate = wxPyBeginAllowThreads();
25526 (arg1)->SetChangedWindow(arg2);
25527 wxPyEndAllowThreads(__tstate);
25528 if (PyErr_Occurred()) SWIG_fail;
25529 }
25530 resultobj = SWIG_Py_Void();
25531 return resultobj;
25532 fail:
25533 return NULL;
25534 }
25535
25536
25537 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25538 PyObject *resultobj = 0;
25539 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25540 wxWindow *result = 0 ;
25541 void *argp1 = 0 ;
25542 int res1 = 0 ;
25543 PyObject *swig_obj[1] ;
25544
25545 if (!args) SWIG_fail;
25546 swig_obj[0] = args;
25547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25548 if (!SWIG_IsOK(res1)) {
25549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25550 }
25551 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25552 {
25553 PyThreadState* __tstate = wxPyBeginAllowThreads();
25554 result = (wxWindow *)(arg1)->GetChangedWindow();
25555 wxPyEndAllowThreads(__tstate);
25556 if (PyErr_Occurred()) SWIG_fail;
25557 }
25558 {
25559 resultobj = wxPyMake_wxObject(result, (bool)0);
25560 }
25561 return resultobj;
25562 fail:
25563 return NULL;
25564 }
25565
25566
25567 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25568 PyObject *obj;
25569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25570 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25571 return SWIG_Py_Void();
25572 }
25573
25574 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25575 return SWIG_Python_InitShadowInstance(args);
25576 }
25577
25578 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25579 PyObject *resultobj = 0;
25580 int arg1 = (int) 0 ;
25581 wxQueryNewPaletteEvent *result = 0 ;
25582 int val1 ;
25583 int ecode1 = 0 ;
25584 PyObject * obj0 = 0 ;
25585 char * kwnames[] = {
25586 (char *) "winid", NULL
25587 };
25588
25589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25590 if (obj0) {
25591 ecode1 = SWIG_AsVal_int(obj0, &val1);
25592 if (!SWIG_IsOK(ecode1)) {
25593 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25594 }
25595 arg1 = static_cast< int >(val1);
25596 }
25597 {
25598 PyThreadState* __tstate = wxPyBeginAllowThreads();
25599 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25600 wxPyEndAllowThreads(__tstate);
25601 if (PyErr_Occurred()) SWIG_fail;
25602 }
25603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25604 return resultobj;
25605 fail:
25606 return NULL;
25607 }
25608
25609
25610 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25611 PyObject *resultobj = 0;
25612 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25613 bool arg2 ;
25614 void *argp1 = 0 ;
25615 int res1 = 0 ;
25616 bool val2 ;
25617 int ecode2 = 0 ;
25618 PyObject * obj0 = 0 ;
25619 PyObject * obj1 = 0 ;
25620 char * kwnames[] = {
25621 (char *) "self",(char *) "realized", NULL
25622 };
25623
25624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25626 if (!SWIG_IsOK(res1)) {
25627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25628 }
25629 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25630 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25631 if (!SWIG_IsOK(ecode2)) {
25632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25633 }
25634 arg2 = static_cast< bool >(val2);
25635 {
25636 PyThreadState* __tstate = wxPyBeginAllowThreads();
25637 (arg1)->SetPaletteRealized(arg2);
25638 wxPyEndAllowThreads(__tstate);
25639 if (PyErr_Occurred()) SWIG_fail;
25640 }
25641 resultobj = SWIG_Py_Void();
25642 return resultobj;
25643 fail:
25644 return NULL;
25645 }
25646
25647
25648 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25649 PyObject *resultobj = 0;
25650 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25651 bool result;
25652 void *argp1 = 0 ;
25653 int res1 = 0 ;
25654 PyObject *swig_obj[1] ;
25655
25656 if (!args) SWIG_fail;
25657 swig_obj[0] = args;
25658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25659 if (!SWIG_IsOK(res1)) {
25660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25661 }
25662 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25663 {
25664 PyThreadState* __tstate = wxPyBeginAllowThreads();
25665 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25666 wxPyEndAllowThreads(__tstate);
25667 if (PyErr_Occurred()) SWIG_fail;
25668 }
25669 {
25670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25671 }
25672 return resultobj;
25673 fail:
25674 return NULL;
25675 }
25676
25677
25678 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25679 PyObject *obj;
25680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25681 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25682 return SWIG_Py_Void();
25683 }
25684
25685 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25686 return SWIG_Python_InitShadowInstance(args);
25687 }
25688
25689 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25690 PyObject *resultobj = 0;
25691 wxNavigationKeyEvent *result = 0 ;
25692
25693 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25694 {
25695 PyThreadState* __tstate = wxPyBeginAllowThreads();
25696 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25697 wxPyEndAllowThreads(__tstate);
25698 if (PyErr_Occurred()) SWIG_fail;
25699 }
25700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25701 return resultobj;
25702 fail:
25703 return NULL;
25704 }
25705
25706
25707 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25708 PyObject *resultobj = 0;
25709 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25710 bool result;
25711 void *argp1 = 0 ;
25712 int res1 = 0 ;
25713 PyObject *swig_obj[1] ;
25714
25715 if (!args) SWIG_fail;
25716 swig_obj[0] = args;
25717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25718 if (!SWIG_IsOK(res1)) {
25719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25720 }
25721 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25722 {
25723 PyThreadState* __tstate = wxPyBeginAllowThreads();
25724 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25725 wxPyEndAllowThreads(__tstate);
25726 if (PyErr_Occurred()) SWIG_fail;
25727 }
25728 {
25729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25730 }
25731 return resultobj;
25732 fail:
25733 return NULL;
25734 }
25735
25736
25737 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25738 PyObject *resultobj = 0;
25739 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25740 bool arg2 ;
25741 void *argp1 = 0 ;
25742 int res1 = 0 ;
25743 bool val2 ;
25744 int ecode2 = 0 ;
25745 PyObject * obj0 = 0 ;
25746 PyObject * obj1 = 0 ;
25747 char * kwnames[] = {
25748 (char *) "self",(char *) "forward", NULL
25749 };
25750
25751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25753 if (!SWIG_IsOK(res1)) {
25754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25755 }
25756 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25757 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25758 if (!SWIG_IsOK(ecode2)) {
25759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25760 }
25761 arg2 = static_cast< bool >(val2);
25762 {
25763 PyThreadState* __tstate = wxPyBeginAllowThreads();
25764 (arg1)->SetDirection(arg2);
25765 wxPyEndAllowThreads(__tstate);
25766 if (PyErr_Occurred()) SWIG_fail;
25767 }
25768 resultobj = SWIG_Py_Void();
25769 return resultobj;
25770 fail:
25771 return NULL;
25772 }
25773
25774
25775 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25776 PyObject *resultobj = 0;
25777 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25778 bool result;
25779 void *argp1 = 0 ;
25780 int res1 = 0 ;
25781 PyObject *swig_obj[1] ;
25782
25783 if (!args) SWIG_fail;
25784 swig_obj[0] = args;
25785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25786 if (!SWIG_IsOK(res1)) {
25787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25788 }
25789 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25790 {
25791 PyThreadState* __tstate = wxPyBeginAllowThreads();
25792 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25793 wxPyEndAllowThreads(__tstate);
25794 if (PyErr_Occurred()) SWIG_fail;
25795 }
25796 {
25797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25798 }
25799 return resultobj;
25800 fail:
25801 return NULL;
25802 }
25803
25804
25805 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25806 PyObject *resultobj = 0;
25807 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25808 bool arg2 ;
25809 void *argp1 = 0 ;
25810 int res1 = 0 ;
25811 bool val2 ;
25812 int ecode2 = 0 ;
25813 PyObject * obj0 = 0 ;
25814 PyObject * obj1 = 0 ;
25815 char * kwnames[] = {
25816 (char *) "self",(char *) "ischange", NULL
25817 };
25818
25819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25821 if (!SWIG_IsOK(res1)) {
25822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25823 }
25824 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25825 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25826 if (!SWIG_IsOK(ecode2)) {
25827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25828 }
25829 arg2 = static_cast< bool >(val2);
25830 {
25831 PyThreadState* __tstate = wxPyBeginAllowThreads();
25832 (arg1)->SetWindowChange(arg2);
25833 wxPyEndAllowThreads(__tstate);
25834 if (PyErr_Occurred()) SWIG_fail;
25835 }
25836 resultobj = SWIG_Py_Void();
25837 return resultobj;
25838 fail:
25839 return NULL;
25840 }
25841
25842
25843 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25844 PyObject *resultobj = 0;
25845 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25846 bool result;
25847 void *argp1 = 0 ;
25848 int res1 = 0 ;
25849 PyObject *swig_obj[1] ;
25850
25851 if (!args) SWIG_fail;
25852 swig_obj[0] = args;
25853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25854 if (!SWIG_IsOK(res1)) {
25855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25856 }
25857 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25858 {
25859 PyThreadState* __tstate = wxPyBeginAllowThreads();
25860 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25861 wxPyEndAllowThreads(__tstate);
25862 if (PyErr_Occurred()) SWIG_fail;
25863 }
25864 {
25865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25866 }
25867 return resultobj;
25868 fail:
25869 return NULL;
25870 }
25871
25872
25873 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25874 PyObject *resultobj = 0;
25875 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25876 bool arg2 ;
25877 void *argp1 = 0 ;
25878 int res1 = 0 ;
25879 bool val2 ;
25880 int ecode2 = 0 ;
25881 PyObject * obj0 = 0 ;
25882 PyObject * obj1 = 0 ;
25883 char * kwnames[] = {
25884 (char *) "self",(char *) "bIs", NULL
25885 };
25886
25887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25889 if (!SWIG_IsOK(res1)) {
25890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25891 }
25892 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25893 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25894 if (!SWIG_IsOK(ecode2)) {
25895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25896 }
25897 arg2 = static_cast< bool >(val2);
25898 {
25899 PyThreadState* __tstate = wxPyBeginAllowThreads();
25900 (arg1)->SetFromTab(arg2);
25901 wxPyEndAllowThreads(__tstate);
25902 if (PyErr_Occurred()) SWIG_fail;
25903 }
25904 resultobj = SWIG_Py_Void();
25905 return resultobj;
25906 fail:
25907 return NULL;
25908 }
25909
25910
25911 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25912 PyObject *resultobj = 0;
25913 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25914 long arg2 ;
25915 void *argp1 = 0 ;
25916 int res1 = 0 ;
25917 long val2 ;
25918 int ecode2 = 0 ;
25919 PyObject * obj0 = 0 ;
25920 PyObject * obj1 = 0 ;
25921 char * kwnames[] = {
25922 (char *) "self",(char *) "flags", NULL
25923 };
25924
25925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25927 if (!SWIG_IsOK(res1)) {
25928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25929 }
25930 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25931 ecode2 = SWIG_AsVal_long(obj1, &val2);
25932 if (!SWIG_IsOK(ecode2)) {
25933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25934 }
25935 arg2 = static_cast< long >(val2);
25936 {
25937 PyThreadState* __tstate = wxPyBeginAllowThreads();
25938 (arg1)->SetFlags(arg2);
25939 wxPyEndAllowThreads(__tstate);
25940 if (PyErr_Occurred()) SWIG_fail;
25941 }
25942 resultobj = SWIG_Py_Void();
25943 return resultobj;
25944 fail:
25945 return NULL;
25946 }
25947
25948
25949 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25950 PyObject *resultobj = 0;
25951 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25952 wxWindow *result = 0 ;
25953 void *argp1 = 0 ;
25954 int res1 = 0 ;
25955 PyObject *swig_obj[1] ;
25956
25957 if (!args) SWIG_fail;
25958 swig_obj[0] = args;
25959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25960 if (!SWIG_IsOK(res1)) {
25961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25962 }
25963 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25964 {
25965 PyThreadState* __tstate = wxPyBeginAllowThreads();
25966 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25967 wxPyEndAllowThreads(__tstate);
25968 if (PyErr_Occurred()) SWIG_fail;
25969 }
25970 {
25971 resultobj = wxPyMake_wxObject(result, (bool)0);
25972 }
25973 return resultobj;
25974 fail:
25975 return NULL;
25976 }
25977
25978
25979 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25980 PyObject *resultobj = 0;
25981 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25982 wxWindow *arg2 = (wxWindow *) 0 ;
25983 void *argp1 = 0 ;
25984 int res1 = 0 ;
25985 void *argp2 = 0 ;
25986 int res2 = 0 ;
25987 PyObject * obj0 = 0 ;
25988 PyObject * obj1 = 0 ;
25989 char * kwnames[] = {
25990 (char *) "self",(char *) "win", NULL
25991 };
25992
25993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25995 if (!SWIG_IsOK(res1)) {
25996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25997 }
25998 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25999 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26000 if (!SWIG_IsOK(res2)) {
26001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26002 }
26003 arg2 = reinterpret_cast< wxWindow * >(argp2);
26004 {
26005 PyThreadState* __tstate = wxPyBeginAllowThreads();
26006 (arg1)->SetCurrentFocus(arg2);
26007 wxPyEndAllowThreads(__tstate);
26008 if (PyErr_Occurred()) SWIG_fail;
26009 }
26010 resultobj = SWIG_Py_Void();
26011 return resultobj;
26012 fail:
26013 return NULL;
26014 }
26015
26016
26017 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26018 PyObject *obj;
26019 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26020 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26021 return SWIG_Py_Void();
26022 }
26023
26024 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26025 return SWIG_Python_InitShadowInstance(args);
26026 }
26027
26028 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26029 PyObject *resultobj = 0;
26030 wxWindow *arg1 = (wxWindow *) NULL ;
26031 wxWindowCreateEvent *result = 0 ;
26032 void *argp1 = 0 ;
26033 int res1 = 0 ;
26034 PyObject * obj0 = 0 ;
26035 char * kwnames[] = {
26036 (char *) "win", NULL
26037 };
26038
26039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26040 if (obj0) {
26041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26042 if (!SWIG_IsOK(res1)) {
26043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26044 }
26045 arg1 = reinterpret_cast< wxWindow * >(argp1);
26046 }
26047 {
26048 PyThreadState* __tstate = wxPyBeginAllowThreads();
26049 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26050 wxPyEndAllowThreads(__tstate);
26051 if (PyErr_Occurred()) SWIG_fail;
26052 }
26053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26054 return resultobj;
26055 fail:
26056 return NULL;
26057 }
26058
26059
26060 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26061 PyObject *resultobj = 0;
26062 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26063 wxWindow *result = 0 ;
26064 void *argp1 = 0 ;
26065 int res1 = 0 ;
26066 PyObject *swig_obj[1] ;
26067
26068 if (!args) SWIG_fail;
26069 swig_obj[0] = args;
26070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26071 if (!SWIG_IsOK(res1)) {
26072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26073 }
26074 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26075 {
26076 PyThreadState* __tstate = wxPyBeginAllowThreads();
26077 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26078 wxPyEndAllowThreads(__tstate);
26079 if (PyErr_Occurred()) SWIG_fail;
26080 }
26081 {
26082 resultobj = wxPyMake_wxObject(result, (bool)0);
26083 }
26084 return resultobj;
26085 fail:
26086 return NULL;
26087 }
26088
26089
26090 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26091 PyObject *obj;
26092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26093 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26094 return SWIG_Py_Void();
26095 }
26096
26097 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26098 return SWIG_Python_InitShadowInstance(args);
26099 }
26100
26101 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26102 PyObject *resultobj = 0;
26103 wxWindow *arg1 = (wxWindow *) NULL ;
26104 wxWindowDestroyEvent *result = 0 ;
26105 void *argp1 = 0 ;
26106 int res1 = 0 ;
26107 PyObject * obj0 = 0 ;
26108 char * kwnames[] = {
26109 (char *) "win", NULL
26110 };
26111
26112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26113 if (obj0) {
26114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26115 if (!SWIG_IsOK(res1)) {
26116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26117 }
26118 arg1 = reinterpret_cast< wxWindow * >(argp1);
26119 }
26120 {
26121 PyThreadState* __tstate = wxPyBeginAllowThreads();
26122 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26123 wxPyEndAllowThreads(__tstate);
26124 if (PyErr_Occurred()) SWIG_fail;
26125 }
26126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26127 return resultobj;
26128 fail:
26129 return NULL;
26130 }
26131
26132
26133 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26134 PyObject *resultobj = 0;
26135 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26136 wxWindow *result = 0 ;
26137 void *argp1 = 0 ;
26138 int res1 = 0 ;
26139 PyObject *swig_obj[1] ;
26140
26141 if (!args) SWIG_fail;
26142 swig_obj[0] = args;
26143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26144 if (!SWIG_IsOK(res1)) {
26145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26146 }
26147 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26148 {
26149 PyThreadState* __tstate = wxPyBeginAllowThreads();
26150 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26151 wxPyEndAllowThreads(__tstate);
26152 if (PyErr_Occurred()) SWIG_fail;
26153 }
26154 {
26155 resultobj = wxPyMake_wxObject(result, (bool)0);
26156 }
26157 return resultobj;
26158 fail:
26159 return NULL;
26160 }
26161
26162
26163 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26164 PyObject *obj;
26165 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26166 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26167 return SWIG_Py_Void();
26168 }
26169
26170 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26171 return SWIG_Python_InitShadowInstance(args);
26172 }
26173
26174 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26175 PyObject *resultobj = 0;
26176 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26177 int arg2 = (int) 0 ;
26178 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26179 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26180 wxContextMenuEvent *result = 0 ;
26181 int val1 ;
26182 int ecode1 = 0 ;
26183 int val2 ;
26184 int ecode2 = 0 ;
26185 wxPoint temp3 ;
26186 PyObject * obj0 = 0 ;
26187 PyObject * obj1 = 0 ;
26188 PyObject * obj2 = 0 ;
26189 char * kwnames[] = {
26190 (char *) "type",(char *) "winid",(char *) "pt", NULL
26191 };
26192
26193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26194 if (obj0) {
26195 ecode1 = SWIG_AsVal_int(obj0, &val1);
26196 if (!SWIG_IsOK(ecode1)) {
26197 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26198 }
26199 arg1 = static_cast< wxEventType >(val1);
26200 }
26201 if (obj1) {
26202 ecode2 = SWIG_AsVal_int(obj1, &val2);
26203 if (!SWIG_IsOK(ecode2)) {
26204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26205 }
26206 arg2 = static_cast< int >(val2);
26207 }
26208 if (obj2) {
26209 {
26210 arg3 = &temp3;
26211 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26212 }
26213 }
26214 {
26215 PyThreadState* __tstate = wxPyBeginAllowThreads();
26216 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26217 wxPyEndAllowThreads(__tstate);
26218 if (PyErr_Occurred()) SWIG_fail;
26219 }
26220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26221 return resultobj;
26222 fail:
26223 return NULL;
26224 }
26225
26226
26227 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26228 PyObject *resultobj = 0;
26229 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26230 wxPoint *result = 0 ;
26231 void *argp1 = 0 ;
26232 int res1 = 0 ;
26233 PyObject *swig_obj[1] ;
26234
26235 if (!args) SWIG_fail;
26236 swig_obj[0] = args;
26237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26238 if (!SWIG_IsOK(res1)) {
26239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26240 }
26241 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26242 {
26243 PyThreadState* __tstate = wxPyBeginAllowThreads();
26244 {
26245 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26246 result = (wxPoint *) &_result_ref;
26247 }
26248 wxPyEndAllowThreads(__tstate);
26249 if (PyErr_Occurred()) SWIG_fail;
26250 }
26251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26252 return resultobj;
26253 fail:
26254 return NULL;
26255 }
26256
26257
26258 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26259 PyObject *resultobj = 0;
26260 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26261 wxPoint *arg2 = 0 ;
26262 void *argp1 = 0 ;
26263 int res1 = 0 ;
26264 wxPoint temp2 ;
26265 PyObject * obj0 = 0 ;
26266 PyObject * obj1 = 0 ;
26267 char * kwnames[] = {
26268 (char *) "self",(char *) "pos", NULL
26269 };
26270
26271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26273 if (!SWIG_IsOK(res1)) {
26274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26275 }
26276 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26277 {
26278 arg2 = &temp2;
26279 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26280 }
26281 {
26282 PyThreadState* __tstate = wxPyBeginAllowThreads();
26283 (arg1)->SetPosition((wxPoint const &)*arg2);
26284 wxPyEndAllowThreads(__tstate);
26285 if (PyErr_Occurred()) SWIG_fail;
26286 }
26287 resultobj = SWIG_Py_Void();
26288 return resultobj;
26289 fail:
26290 return NULL;
26291 }
26292
26293
26294 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26295 PyObject *obj;
26296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26297 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26298 return SWIG_Py_Void();
26299 }
26300
26301 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26302 return SWIG_Python_InitShadowInstance(args);
26303 }
26304
26305 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26306 PyObject *resultobj = 0;
26307 wxIdleEvent *result = 0 ;
26308
26309 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26310 {
26311 PyThreadState* __tstate = wxPyBeginAllowThreads();
26312 result = (wxIdleEvent *)new wxIdleEvent();
26313 wxPyEndAllowThreads(__tstate);
26314 if (PyErr_Occurred()) SWIG_fail;
26315 }
26316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26317 return resultobj;
26318 fail:
26319 return NULL;
26320 }
26321
26322
26323 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26324 PyObject *resultobj = 0;
26325 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26326 bool arg2 = (bool) true ;
26327 void *argp1 = 0 ;
26328 int res1 = 0 ;
26329 bool val2 ;
26330 int ecode2 = 0 ;
26331 PyObject * obj0 = 0 ;
26332 PyObject * obj1 = 0 ;
26333 char * kwnames[] = {
26334 (char *) "self",(char *) "needMore", NULL
26335 };
26336
26337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26339 if (!SWIG_IsOK(res1)) {
26340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26341 }
26342 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26343 if (obj1) {
26344 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26345 if (!SWIG_IsOK(ecode2)) {
26346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26347 }
26348 arg2 = static_cast< bool >(val2);
26349 }
26350 {
26351 PyThreadState* __tstate = wxPyBeginAllowThreads();
26352 (arg1)->RequestMore(arg2);
26353 wxPyEndAllowThreads(__tstate);
26354 if (PyErr_Occurred()) SWIG_fail;
26355 }
26356 resultobj = SWIG_Py_Void();
26357 return resultobj;
26358 fail:
26359 return NULL;
26360 }
26361
26362
26363 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26364 PyObject *resultobj = 0;
26365 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26366 bool result;
26367 void *argp1 = 0 ;
26368 int res1 = 0 ;
26369 PyObject *swig_obj[1] ;
26370
26371 if (!args) SWIG_fail;
26372 swig_obj[0] = args;
26373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26374 if (!SWIG_IsOK(res1)) {
26375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26376 }
26377 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26378 {
26379 PyThreadState* __tstate = wxPyBeginAllowThreads();
26380 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 {
26385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26386 }
26387 return resultobj;
26388 fail:
26389 return NULL;
26390 }
26391
26392
26393 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26394 PyObject *resultobj = 0;
26395 wxIdleMode arg1 ;
26396 int val1 ;
26397 int ecode1 = 0 ;
26398 PyObject * obj0 = 0 ;
26399 char * kwnames[] = {
26400 (char *) "mode", NULL
26401 };
26402
26403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26404 ecode1 = SWIG_AsVal_int(obj0, &val1);
26405 if (!SWIG_IsOK(ecode1)) {
26406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26407 }
26408 arg1 = static_cast< wxIdleMode >(val1);
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 wxIdleEvent::SetMode(arg1);
26412 wxPyEndAllowThreads(__tstate);
26413 if (PyErr_Occurred()) SWIG_fail;
26414 }
26415 resultobj = SWIG_Py_Void();
26416 return resultobj;
26417 fail:
26418 return NULL;
26419 }
26420
26421
26422 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26423 PyObject *resultobj = 0;
26424 wxIdleMode result;
26425
26426 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26427 {
26428 PyThreadState* __tstate = wxPyBeginAllowThreads();
26429 result = (wxIdleMode)wxIdleEvent::GetMode();
26430 wxPyEndAllowThreads(__tstate);
26431 if (PyErr_Occurred()) SWIG_fail;
26432 }
26433 resultobj = SWIG_From_int(static_cast< int >(result));
26434 return resultobj;
26435 fail:
26436 return NULL;
26437 }
26438
26439
26440 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26441 PyObject *resultobj = 0;
26442 wxWindow *arg1 = (wxWindow *) 0 ;
26443 bool result;
26444 void *argp1 = 0 ;
26445 int res1 = 0 ;
26446 PyObject * obj0 = 0 ;
26447 char * kwnames[] = {
26448 (char *) "win", NULL
26449 };
26450
26451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26453 if (!SWIG_IsOK(res1)) {
26454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26455 }
26456 arg1 = reinterpret_cast< wxWindow * >(argp1);
26457 {
26458 PyThreadState* __tstate = wxPyBeginAllowThreads();
26459 result = (bool)wxIdleEvent::CanSend(arg1);
26460 wxPyEndAllowThreads(__tstate);
26461 if (PyErr_Occurred()) SWIG_fail;
26462 }
26463 {
26464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26465 }
26466 return resultobj;
26467 fail:
26468 return NULL;
26469 }
26470
26471
26472 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26473 PyObject *obj;
26474 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26475 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26476 return SWIG_Py_Void();
26477 }
26478
26479 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26480 return SWIG_Python_InitShadowInstance(args);
26481 }
26482
26483 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26484 PyObject *resultobj = 0;
26485 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26486 int arg2 = (int) 0 ;
26487 wxClipboardTextEvent *result = 0 ;
26488 int val1 ;
26489 int ecode1 = 0 ;
26490 int val2 ;
26491 int ecode2 = 0 ;
26492 PyObject * obj0 = 0 ;
26493 PyObject * obj1 = 0 ;
26494 char * kwnames[] = {
26495 (char *) "type",(char *) "winid", NULL
26496 };
26497
26498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26499 if (obj0) {
26500 ecode1 = SWIG_AsVal_int(obj0, &val1);
26501 if (!SWIG_IsOK(ecode1)) {
26502 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26503 }
26504 arg1 = static_cast< wxEventType >(val1);
26505 }
26506 if (obj1) {
26507 ecode2 = SWIG_AsVal_int(obj1, &val2);
26508 if (!SWIG_IsOK(ecode2)) {
26509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26510 }
26511 arg2 = static_cast< int >(val2);
26512 }
26513 {
26514 PyThreadState* __tstate = wxPyBeginAllowThreads();
26515 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26516 wxPyEndAllowThreads(__tstate);
26517 if (PyErr_Occurred()) SWIG_fail;
26518 }
26519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26520 return resultobj;
26521 fail:
26522 return NULL;
26523 }
26524
26525
26526 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26527 PyObject *obj;
26528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26529 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26530 return SWIG_Py_Void();
26531 }
26532
26533 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26534 return SWIG_Python_InitShadowInstance(args);
26535 }
26536
26537 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26538 PyObject *resultobj = 0;
26539 int arg1 = (int) 0 ;
26540 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26541 wxPyEvent *result = 0 ;
26542 int val1 ;
26543 int ecode1 = 0 ;
26544 int val2 ;
26545 int ecode2 = 0 ;
26546 PyObject * obj0 = 0 ;
26547 PyObject * obj1 = 0 ;
26548 char * kwnames[] = {
26549 (char *) "winid",(char *) "eventType", NULL
26550 };
26551
26552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26553 if (obj0) {
26554 ecode1 = SWIG_AsVal_int(obj0, &val1);
26555 if (!SWIG_IsOK(ecode1)) {
26556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26557 }
26558 arg1 = static_cast< int >(val1);
26559 }
26560 if (obj1) {
26561 ecode2 = SWIG_AsVal_int(obj1, &val2);
26562 if (!SWIG_IsOK(ecode2)) {
26563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26564 }
26565 arg2 = static_cast< wxEventType >(val2);
26566 }
26567 {
26568 PyThreadState* __tstate = wxPyBeginAllowThreads();
26569 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26570 wxPyEndAllowThreads(__tstate);
26571 if (PyErr_Occurred()) SWIG_fail;
26572 }
26573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26574 return resultobj;
26575 fail:
26576 return NULL;
26577 }
26578
26579
26580 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26581 PyObject *resultobj = 0;
26582 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26583 void *argp1 = 0 ;
26584 int res1 = 0 ;
26585 PyObject *swig_obj[1] ;
26586
26587 if (!args) SWIG_fail;
26588 swig_obj[0] = args;
26589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26590 if (!SWIG_IsOK(res1)) {
26591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26592 }
26593 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26594 {
26595 PyThreadState* __tstate = wxPyBeginAllowThreads();
26596 delete arg1;
26597
26598 wxPyEndAllowThreads(__tstate);
26599 if (PyErr_Occurred()) SWIG_fail;
26600 }
26601 resultobj = SWIG_Py_Void();
26602 return resultobj;
26603 fail:
26604 return NULL;
26605 }
26606
26607
26608 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26609 PyObject *resultobj = 0;
26610 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26611 PyObject *arg2 = (PyObject *) 0 ;
26612 void *argp1 = 0 ;
26613 int res1 = 0 ;
26614 PyObject * obj0 = 0 ;
26615 PyObject * obj1 = 0 ;
26616 char * kwnames[] = {
26617 (char *) "self",(char *) "self", NULL
26618 };
26619
26620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26622 if (!SWIG_IsOK(res1)) {
26623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26624 }
26625 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26626 arg2 = obj1;
26627 {
26628 PyThreadState* __tstate = wxPyBeginAllowThreads();
26629 (arg1)->SetSelf(arg2);
26630 wxPyEndAllowThreads(__tstate);
26631 if (PyErr_Occurred()) SWIG_fail;
26632 }
26633 resultobj = SWIG_Py_Void();
26634 return resultobj;
26635 fail:
26636 return NULL;
26637 }
26638
26639
26640 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26641 PyObject *resultobj = 0;
26642 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26643 PyObject *result = 0 ;
26644 void *argp1 = 0 ;
26645 int res1 = 0 ;
26646 PyObject *swig_obj[1] ;
26647
26648 if (!args) SWIG_fail;
26649 swig_obj[0] = args;
26650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26651 if (!SWIG_IsOK(res1)) {
26652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26653 }
26654 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26655 {
26656 PyThreadState* __tstate = wxPyBeginAllowThreads();
26657 result = (PyObject *)(arg1)->GetSelf();
26658 wxPyEndAllowThreads(__tstate);
26659 if (PyErr_Occurred()) SWIG_fail;
26660 }
26661 resultobj = result;
26662 return resultobj;
26663 fail:
26664 return NULL;
26665 }
26666
26667
26668 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26669 PyObject *obj;
26670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26671 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26672 return SWIG_Py_Void();
26673 }
26674
26675 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26676 return SWIG_Python_InitShadowInstance(args);
26677 }
26678
26679 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26680 PyObject *resultobj = 0;
26681 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26682 int arg2 = (int) 0 ;
26683 wxPyCommandEvent *result = 0 ;
26684 int val1 ;
26685 int ecode1 = 0 ;
26686 int val2 ;
26687 int ecode2 = 0 ;
26688 PyObject * obj0 = 0 ;
26689 PyObject * obj1 = 0 ;
26690 char * kwnames[] = {
26691 (char *) "eventType",(char *) "id", NULL
26692 };
26693
26694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26695 if (obj0) {
26696 ecode1 = SWIG_AsVal_int(obj0, &val1);
26697 if (!SWIG_IsOK(ecode1)) {
26698 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26699 }
26700 arg1 = static_cast< wxEventType >(val1);
26701 }
26702 if (obj1) {
26703 ecode2 = SWIG_AsVal_int(obj1, &val2);
26704 if (!SWIG_IsOK(ecode2)) {
26705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26706 }
26707 arg2 = static_cast< int >(val2);
26708 }
26709 {
26710 PyThreadState* __tstate = wxPyBeginAllowThreads();
26711 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26712 wxPyEndAllowThreads(__tstate);
26713 if (PyErr_Occurred()) SWIG_fail;
26714 }
26715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26716 return resultobj;
26717 fail:
26718 return NULL;
26719 }
26720
26721
26722 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26723 PyObject *resultobj = 0;
26724 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26725 void *argp1 = 0 ;
26726 int res1 = 0 ;
26727 PyObject *swig_obj[1] ;
26728
26729 if (!args) SWIG_fail;
26730 swig_obj[0] = args;
26731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26732 if (!SWIG_IsOK(res1)) {
26733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26734 }
26735 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26736 {
26737 PyThreadState* __tstate = wxPyBeginAllowThreads();
26738 delete arg1;
26739
26740 wxPyEndAllowThreads(__tstate);
26741 if (PyErr_Occurred()) SWIG_fail;
26742 }
26743 resultobj = SWIG_Py_Void();
26744 return resultobj;
26745 fail:
26746 return NULL;
26747 }
26748
26749
26750 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26751 PyObject *resultobj = 0;
26752 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26753 PyObject *arg2 = (PyObject *) 0 ;
26754 void *argp1 = 0 ;
26755 int res1 = 0 ;
26756 PyObject * obj0 = 0 ;
26757 PyObject * obj1 = 0 ;
26758 char * kwnames[] = {
26759 (char *) "self",(char *) "self", NULL
26760 };
26761
26762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26764 if (!SWIG_IsOK(res1)) {
26765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26766 }
26767 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26768 arg2 = obj1;
26769 {
26770 PyThreadState* __tstate = wxPyBeginAllowThreads();
26771 (arg1)->SetSelf(arg2);
26772 wxPyEndAllowThreads(__tstate);
26773 if (PyErr_Occurred()) SWIG_fail;
26774 }
26775 resultobj = SWIG_Py_Void();
26776 return resultobj;
26777 fail:
26778 return NULL;
26779 }
26780
26781
26782 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26783 PyObject *resultobj = 0;
26784 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26785 PyObject *result = 0 ;
26786 void *argp1 = 0 ;
26787 int res1 = 0 ;
26788 PyObject *swig_obj[1] ;
26789
26790 if (!args) SWIG_fail;
26791 swig_obj[0] = args;
26792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26793 if (!SWIG_IsOK(res1)) {
26794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26795 }
26796 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26797 {
26798 PyThreadState* __tstate = wxPyBeginAllowThreads();
26799 result = (PyObject *)(arg1)->GetSelf();
26800 wxPyEndAllowThreads(__tstate);
26801 if (PyErr_Occurred()) SWIG_fail;
26802 }
26803 resultobj = result;
26804 return resultobj;
26805 fail:
26806 return NULL;
26807 }
26808
26809
26810 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26811 PyObject *obj;
26812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26813 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26814 return SWIG_Py_Void();
26815 }
26816
26817 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26818 return SWIG_Python_InitShadowInstance(args);
26819 }
26820
26821 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26822 PyObject *resultobj = 0;
26823 wxWindow *arg1 = (wxWindow *) 0 ;
26824 wxDateTime *arg2 = 0 ;
26825 wxEventType arg3 ;
26826 wxDateEvent *result = 0 ;
26827 void *argp1 = 0 ;
26828 int res1 = 0 ;
26829 void *argp2 = 0 ;
26830 int res2 = 0 ;
26831 int val3 ;
26832 int ecode3 = 0 ;
26833 PyObject * obj0 = 0 ;
26834 PyObject * obj1 = 0 ;
26835 PyObject * obj2 = 0 ;
26836 char * kwnames[] = {
26837 (char *) "win",(char *) "dt",(char *) "type", NULL
26838 };
26839
26840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26842 if (!SWIG_IsOK(res1)) {
26843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26844 }
26845 arg1 = reinterpret_cast< wxWindow * >(argp1);
26846 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26847 if (!SWIG_IsOK(res2)) {
26848 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26849 }
26850 if (!argp2) {
26851 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26852 }
26853 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26854 ecode3 = SWIG_AsVal_int(obj2, &val3);
26855 if (!SWIG_IsOK(ecode3)) {
26856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26857 }
26858 arg3 = static_cast< wxEventType >(val3);
26859 {
26860 PyThreadState* __tstate = wxPyBeginAllowThreads();
26861 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26862 wxPyEndAllowThreads(__tstate);
26863 if (PyErr_Occurred()) SWIG_fail;
26864 }
26865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26866 return resultobj;
26867 fail:
26868 return NULL;
26869 }
26870
26871
26872 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26873 PyObject *resultobj = 0;
26874 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26875 wxDateTime *result = 0 ;
26876 void *argp1 = 0 ;
26877 int res1 = 0 ;
26878 PyObject *swig_obj[1] ;
26879
26880 if (!args) SWIG_fail;
26881 swig_obj[0] = args;
26882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26883 if (!SWIG_IsOK(res1)) {
26884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26885 }
26886 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26887 {
26888 PyThreadState* __tstate = wxPyBeginAllowThreads();
26889 {
26890 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26891 result = (wxDateTime *) &_result_ref;
26892 }
26893 wxPyEndAllowThreads(__tstate);
26894 if (PyErr_Occurred()) SWIG_fail;
26895 }
26896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26897 return resultobj;
26898 fail:
26899 return NULL;
26900 }
26901
26902
26903 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26904 PyObject *resultobj = 0;
26905 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26906 wxDateTime *arg2 = 0 ;
26907 void *argp1 = 0 ;
26908 int res1 = 0 ;
26909 void *argp2 = 0 ;
26910 int res2 = 0 ;
26911 PyObject * obj0 = 0 ;
26912 PyObject * obj1 = 0 ;
26913 char * kwnames[] = {
26914 (char *) "self",(char *) "date", NULL
26915 };
26916
26917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26919 if (!SWIG_IsOK(res1)) {
26920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26921 }
26922 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26923 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26924 if (!SWIG_IsOK(res2)) {
26925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26926 }
26927 if (!argp2) {
26928 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26929 }
26930 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26931 {
26932 PyThreadState* __tstate = wxPyBeginAllowThreads();
26933 (arg1)->SetDate((wxDateTime const &)*arg2);
26934 wxPyEndAllowThreads(__tstate);
26935 if (PyErr_Occurred()) SWIG_fail;
26936 }
26937 resultobj = SWIG_Py_Void();
26938 return resultobj;
26939 fail:
26940 return NULL;
26941 }
26942
26943
26944 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26945 PyObject *obj;
26946 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26947 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26948 return SWIG_Py_Void();
26949 }
26950
26951 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26952 return SWIG_Python_InitShadowInstance(args);
26953 }
26954
26955 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26956 PyObject *resultobj = 0;
26957 wxPyApp *result = 0 ;
26958
26959 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26960 {
26961 PyThreadState* __tstate = wxPyBeginAllowThreads();
26962 result = (wxPyApp *)new_wxPyApp();
26963 wxPyEndAllowThreads(__tstate);
26964 if (PyErr_Occurred()) SWIG_fail;
26965 }
26966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26967 return resultobj;
26968 fail:
26969 return NULL;
26970 }
26971
26972
26973 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26974 PyObject *resultobj = 0;
26975 wxPyApp *arg1 = (wxPyApp *) 0 ;
26976 void *argp1 = 0 ;
26977 int res1 = 0 ;
26978 PyObject *swig_obj[1] ;
26979
26980 if (!args) SWIG_fail;
26981 swig_obj[0] = args;
26982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26983 if (!SWIG_IsOK(res1)) {
26984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26985 }
26986 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26987 {
26988 PyThreadState* __tstate = wxPyBeginAllowThreads();
26989 delete arg1;
26990
26991 wxPyEndAllowThreads(__tstate);
26992 if (PyErr_Occurred()) SWIG_fail;
26993 }
26994 resultobj = SWIG_Py_Void();
26995 return resultobj;
26996 fail:
26997 return NULL;
26998 }
26999
27000
27001 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27002 PyObject *resultobj = 0;
27003 wxPyApp *arg1 = (wxPyApp *) 0 ;
27004 PyObject *arg2 = (PyObject *) 0 ;
27005 PyObject *arg3 = (PyObject *) 0 ;
27006 bool arg4 ;
27007 void *argp1 = 0 ;
27008 int res1 = 0 ;
27009 bool val4 ;
27010 int ecode4 = 0 ;
27011 PyObject * obj0 = 0 ;
27012 PyObject * obj1 = 0 ;
27013 PyObject * obj2 = 0 ;
27014 PyObject * obj3 = 0 ;
27015 char * kwnames[] = {
27016 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27017 };
27018
27019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27021 if (!SWIG_IsOK(res1)) {
27022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27023 }
27024 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27025 arg2 = obj1;
27026 arg3 = obj2;
27027 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27028 if (!SWIG_IsOK(ecode4)) {
27029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27030 }
27031 arg4 = static_cast< bool >(val4);
27032 {
27033 PyThreadState* __tstate = wxPyBeginAllowThreads();
27034 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27035 wxPyEndAllowThreads(__tstate);
27036 if (PyErr_Occurred()) SWIG_fail;
27037 }
27038 resultobj = SWIG_Py_Void();
27039 return resultobj;
27040 fail:
27041 return NULL;
27042 }
27043
27044
27045 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27046 PyObject *resultobj = 0;
27047 wxPyApp *arg1 = (wxPyApp *) 0 ;
27048 wxString result;
27049 void *argp1 = 0 ;
27050 int res1 = 0 ;
27051 PyObject *swig_obj[1] ;
27052
27053 if (!args) SWIG_fail;
27054 swig_obj[0] = args;
27055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27056 if (!SWIG_IsOK(res1)) {
27057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27058 }
27059 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 result = ((wxPyApp const *)arg1)->GetAppName();
27063 wxPyEndAllowThreads(__tstate);
27064 if (PyErr_Occurred()) SWIG_fail;
27065 }
27066 {
27067 #if wxUSE_UNICODE
27068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27069 #else
27070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27071 #endif
27072 }
27073 return resultobj;
27074 fail:
27075 return NULL;
27076 }
27077
27078
27079 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27080 PyObject *resultobj = 0;
27081 wxPyApp *arg1 = (wxPyApp *) 0 ;
27082 wxString *arg2 = 0 ;
27083 void *argp1 = 0 ;
27084 int res1 = 0 ;
27085 bool temp2 = false ;
27086 PyObject * obj0 = 0 ;
27087 PyObject * obj1 = 0 ;
27088 char * kwnames[] = {
27089 (char *) "self",(char *) "name", NULL
27090 };
27091
27092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27094 if (!SWIG_IsOK(res1)) {
27095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27096 }
27097 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27098 {
27099 arg2 = wxString_in_helper(obj1);
27100 if (arg2 == NULL) SWIG_fail;
27101 temp2 = true;
27102 }
27103 {
27104 PyThreadState* __tstate = wxPyBeginAllowThreads();
27105 (arg1)->SetAppName((wxString const &)*arg2);
27106 wxPyEndAllowThreads(__tstate);
27107 if (PyErr_Occurred()) SWIG_fail;
27108 }
27109 resultobj = SWIG_Py_Void();
27110 {
27111 if (temp2)
27112 delete arg2;
27113 }
27114 return resultobj;
27115 fail:
27116 {
27117 if (temp2)
27118 delete arg2;
27119 }
27120 return NULL;
27121 }
27122
27123
27124 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27125 PyObject *resultobj = 0;
27126 wxPyApp *arg1 = (wxPyApp *) 0 ;
27127 wxString result;
27128 void *argp1 = 0 ;
27129 int res1 = 0 ;
27130 PyObject *swig_obj[1] ;
27131
27132 if (!args) SWIG_fail;
27133 swig_obj[0] = args;
27134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27135 if (!SWIG_IsOK(res1)) {
27136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27137 }
27138 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27139 {
27140 PyThreadState* __tstate = wxPyBeginAllowThreads();
27141 result = ((wxPyApp const *)arg1)->GetClassName();
27142 wxPyEndAllowThreads(__tstate);
27143 if (PyErr_Occurred()) SWIG_fail;
27144 }
27145 {
27146 #if wxUSE_UNICODE
27147 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27148 #else
27149 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27150 #endif
27151 }
27152 return resultobj;
27153 fail:
27154 return NULL;
27155 }
27156
27157
27158 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27159 PyObject *resultobj = 0;
27160 wxPyApp *arg1 = (wxPyApp *) 0 ;
27161 wxString *arg2 = 0 ;
27162 void *argp1 = 0 ;
27163 int res1 = 0 ;
27164 bool temp2 = false ;
27165 PyObject * obj0 = 0 ;
27166 PyObject * obj1 = 0 ;
27167 char * kwnames[] = {
27168 (char *) "self",(char *) "name", NULL
27169 };
27170
27171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27173 if (!SWIG_IsOK(res1)) {
27174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27175 }
27176 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27177 {
27178 arg2 = wxString_in_helper(obj1);
27179 if (arg2 == NULL) SWIG_fail;
27180 temp2 = true;
27181 }
27182 {
27183 PyThreadState* __tstate = wxPyBeginAllowThreads();
27184 (arg1)->SetClassName((wxString const &)*arg2);
27185 wxPyEndAllowThreads(__tstate);
27186 if (PyErr_Occurred()) SWIG_fail;
27187 }
27188 resultobj = SWIG_Py_Void();
27189 {
27190 if (temp2)
27191 delete arg2;
27192 }
27193 return resultobj;
27194 fail:
27195 {
27196 if (temp2)
27197 delete arg2;
27198 }
27199 return NULL;
27200 }
27201
27202
27203 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27204 PyObject *resultobj = 0;
27205 wxPyApp *arg1 = (wxPyApp *) 0 ;
27206 wxString *result = 0 ;
27207 void *argp1 = 0 ;
27208 int res1 = 0 ;
27209 PyObject *swig_obj[1] ;
27210
27211 if (!args) SWIG_fail;
27212 swig_obj[0] = args;
27213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27214 if (!SWIG_IsOK(res1)) {
27215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27216 }
27217 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27218 {
27219 PyThreadState* __tstate = wxPyBeginAllowThreads();
27220 {
27221 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27222 result = (wxString *) &_result_ref;
27223 }
27224 wxPyEndAllowThreads(__tstate);
27225 if (PyErr_Occurred()) SWIG_fail;
27226 }
27227 {
27228 #if wxUSE_UNICODE
27229 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27230 #else
27231 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27232 #endif
27233 }
27234 return resultobj;
27235 fail:
27236 return NULL;
27237 }
27238
27239
27240 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27241 PyObject *resultobj = 0;
27242 wxPyApp *arg1 = (wxPyApp *) 0 ;
27243 wxString *arg2 = 0 ;
27244 void *argp1 = 0 ;
27245 int res1 = 0 ;
27246 bool temp2 = false ;
27247 PyObject * obj0 = 0 ;
27248 PyObject * obj1 = 0 ;
27249 char * kwnames[] = {
27250 (char *) "self",(char *) "name", NULL
27251 };
27252
27253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27255 if (!SWIG_IsOK(res1)) {
27256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27257 }
27258 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27259 {
27260 arg2 = wxString_in_helper(obj1);
27261 if (arg2 == NULL) SWIG_fail;
27262 temp2 = true;
27263 }
27264 {
27265 PyThreadState* __tstate = wxPyBeginAllowThreads();
27266 (arg1)->SetVendorName((wxString const &)*arg2);
27267 wxPyEndAllowThreads(__tstate);
27268 if (PyErr_Occurred()) SWIG_fail;
27269 }
27270 resultobj = SWIG_Py_Void();
27271 {
27272 if (temp2)
27273 delete arg2;
27274 }
27275 return resultobj;
27276 fail:
27277 {
27278 if (temp2)
27279 delete arg2;
27280 }
27281 return NULL;
27282 }
27283
27284
27285 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27286 PyObject *resultobj = 0;
27287 wxPyApp *arg1 = (wxPyApp *) 0 ;
27288 wxAppTraits *result = 0 ;
27289 void *argp1 = 0 ;
27290 int res1 = 0 ;
27291 PyObject *swig_obj[1] ;
27292
27293 if (!args) SWIG_fail;
27294 swig_obj[0] = args;
27295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27296 if (!SWIG_IsOK(res1)) {
27297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27298 }
27299 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27300 {
27301 PyThreadState* __tstate = wxPyBeginAllowThreads();
27302 result = (wxAppTraits *)(arg1)->GetTraits();
27303 wxPyEndAllowThreads(__tstate);
27304 if (PyErr_Occurred()) SWIG_fail;
27305 }
27306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27307 return resultobj;
27308 fail:
27309 return NULL;
27310 }
27311
27312
27313 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27314 PyObject *resultobj = 0;
27315 wxPyApp *arg1 = (wxPyApp *) 0 ;
27316 void *argp1 = 0 ;
27317 int res1 = 0 ;
27318 PyObject *swig_obj[1] ;
27319
27320 if (!args) SWIG_fail;
27321 swig_obj[0] = args;
27322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27323 if (!SWIG_IsOK(res1)) {
27324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27325 }
27326 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27327 {
27328 PyThreadState* __tstate = wxPyBeginAllowThreads();
27329 (arg1)->ProcessPendingEvents();
27330 wxPyEndAllowThreads(__tstate);
27331 if (PyErr_Occurred()) SWIG_fail;
27332 }
27333 resultobj = SWIG_Py_Void();
27334 return resultobj;
27335 fail:
27336 return NULL;
27337 }
27338
27339
27340 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27341 PyObject *resultobj = 0;
27342 wxPyApp *arg1 = (wxPyApp *) 0 ;
27343 bool arg2 = (bool) false ;
27344 bool result;
27345 void *argp1 = 0 ;
27346 int res1 = 0 ;
27347 bool val2 ;
27348 int ecode2 = 0 ;
27349 PyObject * obj0 = 0 ;
27350 PyObject * obj1 = 0 ;
27351 char * kwnames[] = {
27352 (char *) "self",(char *) "onlyIfNeeded", NULL
27353 };
27354
27355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27357 if (!SWIG_IsOK(res1)) {
27358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27359 }
27360 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27361 if (obj1) {
27362 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27363 if (!SWIG_IsOK(ecode2)) {
27364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27365 }
27366 arg2 = static_cast< bool >(val2);
27367 }
27368 {
27369 PyThreadState* __tstate = wxPyBeginAllowThreads();
27370 result = (bool)(arg1)->Yield(arg2);
27371 wxPyEndAllowThreads(__tstate);
27372 if (PyErr_Occurred()) SWIG_fail;
27373 }
27374 {
27375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27376 }
27377 return resultobj;
27378 fail:
27379 return NULL;
27380 }
27381
27382
27383 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27384 PyObject *resultobj = 0;
27385 wxPyApp *arg1 = (wxPyApp *) 0 ;
27386 void *argp1 = 0 ;
27387 int res1 = 0 ;
27388 PyObject *swig_obj[1] ;
27389
27390 if (!args) SWIG_fail;
27391 swig_obj[0] = args;
27392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27393 if (!SWIG_IsOK(res1)) {
27394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27395 }
27396 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27397 {
27398 PyThreadState* __tstate = wxPyBeginAllowThreads();
27399 (arg1)->WakeUpIdle();
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 resultobj = SWIG_Py_Void();
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27411 PyObject *resultobj = 0;
27412 bool result;
27413
27414 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27415 {
27416 PyThreadState* __tstate = wxPyBeginAllowThreads();
27417 result = (bool)wxPyApp::IsMainLoopRunning();
27418 wxPyEndAllowThreads(__tstate);
27419 if (PyErr_Occurred()) SWIG_fail;
27420 }
27421 {
27422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27423 }
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27431 PyObject *resultobj = 0;
27432 wxPyApp *arg1 = (wxPyApp *) 0 ;
27433 int result;
27434 void *argp1 = 0 ;
27435 int res1 = 0 ;
27436 PyObject *swig_obj[1] ;
27437
27438 if (!args) SWIG_fail;
27439 swig_obj[0] = args;
27440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27441 if (!SWIG_IsOK(res1)) {
27442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27443 }
27444 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27445 {
27446 PyThreadState* __tstate = wxPyBeginAllowThreads();
27447 result = (int)(arg1)->MainLoop();
27448 wxPyEndAllowThreads(__tstate);
27449 if (PyErr_Occurred()) SWIG_fail;
27450 }
27451 resultobj = SWIG_From_int(static_cast< int >(result));
27452 return resultobj;
27453 fail:
27454 return NULL;
27455 }
27456
27457
27458 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27459 PyObject *resultobj = 0;
27460 wxPyApp *arg1 = (wxPyApp *) 0 ;
27461 void *argp1 = 0 ;
27462 int res1 = 0 ;
27463 PyObject *swig_obj[1] ;
27464
27465 if (!args) SWIG_fail;
27466 swig_obj[0] = args;
27467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27468 if (!SWIG_IsOK(res1)) {
27469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27470 }
27471 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27472 {
27473 PyThreadState* __tstate = wxPyBeginAllowThreads();
27474 (arg1)->Exit();
27475 wxPyEndAllowThreads(__tstate);
27476 if (PyErr_Occurred()) SWIG_fail;
27477 }
27478 resultobj = SWIG_Py_Void();
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27486 PyObject *resultobj = 0;
27487 wxPyApp *arg1 = (wxPyApp *) 0 ;
27488 void *argp1 = 0 ;
27489 int res1 = 0 ;
27490 PyObject *swig_obj[1] ;
27491
27492 if (!args) SWIG_fail;
27493 swig_obj[0] = args;
27494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27495 if (!SWIG_IsOK(res1)) {
27496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27497 }
27498 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27499 {
27500 PyThreadState* __tstate = wxPyBeginAllowThreads();
27501 (arg1)->ExitMainLoop();
27502 wxPyEndAllowThreads(__tstate);
27503 if (PyErr_Occurred()) SWIG_fail;
27504 }
27505 resultobj = SWIG_Py_Void();
27506 return resultobj;
27507 fail:
27508 return NULL;
27509 }
27510
27511
27512 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27513 PyObject *resultobj = 0;
27514 wxPyApp *arg1 = (wxPyApp *) 0 ;
27515 bool result;
27516 void *argp1 = 0 ;
27517 int res1 = 0 ;
27518 PyObject *swig_obj[1] ;
27519
27520 if (!args) SWIG_fail;
27521 swig_obj[0] = args;
27522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27523 if (!SWIG_IsOK(res1)) {
27524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27525 }
27526 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27527 {
27528 PyThreadState* __tstate = wxPyBeginAllowThreads();
27529 result = (bool)(arg1)->Pending();
27530 wxPyEndAllowThreads(__tstate);
27531 if (PyErr_Occurred()) SWIG_fail;
27532 }
27533 {
27534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27535 }
27536 return resultobj;
27537 fail:
27538 return NULL;
27539 }
27540
27541
27542 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27543 PyObject *resultobj = 0;
27544 wxPyApp *arg1 = (wxPyApp *) 0 ;
27545 bool result;
27546 void *argp1 = 0 ;
27547 int res1 = 0 ;
27548 PyObject *swig_obj[1] ;
27549
27550 if (!args) SWIG_fail;
27551 swig_obj[0] = args;
27552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27553 if (!SWIG_IsOK(res1)) {
27554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27555 }
27556 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27557 {
27558 PyThreadState* __tstate = wxPyBeginAllowThreads();
27559 result = (bool)(arg1)->Dispatch();
27560 wxPyEndAllowThreads(__tstate);
27561 if (PyErr_Occurred()) SWIG_fail;
27562 }
27563 {
27564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27565 }
27566 return resultobj;
27567 fail:
27568 return NULL;
27569 }
27570
27571
27572 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27573 PyObject *resultobj = 0;
27574 wxPyApp *arg1 = (wxPyApp *) 0 ;
27575 bool result;
27576 void *argp1 = 0 ;
27577 int res1 = 0 ;
27578 PyObject *swig_obj[1] ;
27579
27580 if (!args) SWIG_fail;
27581 swig_obj[0] = args;
27582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27583 if (!SWIG_IsOK(res1)) {
27584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27585 }
27586 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27587 {
27588 PyThreadState* __tstate = wxPyBeginAllowThreads();
27589 result = (bool)(arg1)->ProcessIdle();
27590 wxPyEndAllowThreads(__tstate);
27591 if (PyErr_Occurred()) SWIG_fail;
27592 }
27593 {
27594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27595 }
27596 return resultobj;
27597 fail:
27598 return NULL;
27599 }
27600
27601
27602 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27603 PyObject *resultobj = 0;
27604 wxPyApp *arg1 = (wxPyApp *) 0 ;
27605 wxWindow *arg2 = (wxWindow *) 0 ;
27606 wxIdleEvent *arg3 = 0 ;
27607 bool result;
27608 void *argp1 = 0 ;
27609 int res1 = 0 ;
27610 void *argp2 = 0 ;
27611 int res2 = 0 ;
27612 void *argp3 = 0 ;
27613 int res3 = 0 ;
27614 PyObject * obj0 = 0 ;
27615 PyObject * obj1 = 0 ;
27616 PyObject * obj2 = 0 ;
27617 char * kwnames[] = {
27618 (char *) "self",(char *) "win",(char *) "event", NULL
27619 };
27620
27621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27623 if (!SWIG_IsOK(res1)) {
27624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27625 }
27626 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27627 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27628 if (!SWIG_IsOK(res2)) {
27629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27630 }
27631 arg2 = reinterpret_cast< wxWindow * >(argp2);
27632 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27633 if (!SWIG_IsOK(res3)) {
27634 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27635 }
27636 if (!argp3) {
27637 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27638 }
27639 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27640 {
27641 PyThreadState* __tstate = wxPyBeginAllowThreads();
27642 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27643 wxPyEndAllowThreads(__tstate);
27644 if (PyErr_Occurred()) SWIG_fail;
27645 }
27646 {
27647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27648 }
27649 return resultobj;
27650 fail:
27651 return NULL;
27652 }
27653
27654
27655 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27656 PyObject *resultobj = 0;
27657 wxPyApp *arg1 = (wxPyApp *) 0 ;
27658 bool result;
27659 void *argp1 = 0 ;
27660 int res1 = 0 ;
27661 PyObject *swig_obj[1] ;
27662
27663 if (!args) SWIG_fail;
27664 swig_obj[0] = args;
27665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27666 if (!SWIG_IsOK(res1)) {
27667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27668 }
27669 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27670 {
27671 PyThreadState* __tstate = wxPyBeginAllowThreads();
27672 result = (bool)((wxPyApp const *)arg1)->IsActive();
27673 wxPyEndAllowThreads(__tstate);
27674 if (PyErr_Occurred()) SWIG_fail;
27675 }
27676 {
27677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27678 }
27679 return resultobj;
27680 fail:
27681 return NULL;
27682 }
27683
27684
27685 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27686 PyObject *resultobj = 0;
27687 wxPyApp *arg1 = (wxPyApp *) 0 ;
27688 wxWindow *arg2 = (wxWindow *) 0 ;
27689 void *argp1 = 0 ;
27690 int res1 = 0 ;
27691 void *argp2 = 0 ;
27692 int res2 = 0 ;
27693 PyObject * obj0 = 0 ;
27694 PyObject * obj1 = 0 ;
27695 char * kwnames[] = {
27696 (char *) "self",(char *) "win", NULL
27697 };
27698
27699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27701 if (!SWIG_IsOK(res1)) {
27702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27703 }
27704 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27705 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27706 if (!SWIG_IsOK(res2)) {
27707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27708 }
27709 arg2 = reinterpret_cast< wxWindow * >(argp2);
27710 {
27711 PyThreadState* __tstate = wxPyBeginAllowThreads();
27712 (arg1)->SetTopWindow(arg2);
27713 wxPyEndAllowThreads(__tstate);
27714 if (PyErr_Occurred()) SWIG_fail;
27715 }
27716 resultobj = SWIG_Py_Void();
27717 return resultobj;
27718 fail:
27719 return NULL;
27720 }
27721
27722
27723 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27724 PyObject *resultobj = 0;
27725 wxPyApp *arg1 = (wxPyApp *) 0 ;
27726 wxWindow *result = 0 ;
27727 void *argp1 = 0 ;
27728 int res1 = 0 ;
27729 PyObject *swig_obj[1] ;
27730
27731 if (!args) SWIG_fail;
27732 swig_obj[0] = args;
27733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27734 if (!SWIG_IsOK(res1)) {
27735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27736 }
27737 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27738 {
27739 PyThreadState* __tstate = wxPyBeginAllowThreads();
27740 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27741 wxPyEndAllowThreads(__tstate);
27742 if (PyErr_Occurred()) SWIG_fail;
27743 }
27744 {
27745 resultobj = wxPyMake_wxObject(result, (bool)0);
27746 }
27747 return resultobj;
27748 fail:
27749 return NULL;
27750 }
27751
27752
27753 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27754 PyObject *resultobj = 0;
27755 wxPyApp *arg1 = (wxPyApp *) 0 ;
27756 bool arg2 ;
27757 void *argp1 = 0 ;
27758 int res1 = 0 ;
27759 bool val2 ;
27760 int ecode2 = 0 ;
27761 PyObject * obj0 = 0 ;
27762 PyObject * obj1 = 0 ;
27763 char * kwnames[] = {
27764 (char *) "self",(char *) "flag", NULL
27765 };
27766
27767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27769 if (!SWIG_IsOK(res1)) {
27770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27771 }
27772 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27773 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27774 if (!SWIG_IsOK(ecode2)) {
27775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27776 }
27777 arg2 = static_cast< bool >(val2);
27778 {
27779 PyThreadState* __tstate = wxPyBeginAllowThreads();
27780 (arg1)->SetExitOnFrameDelete(arg2);
27781 wxPyEndAllowThreads(__tstate);
27782 if (PyErr_Occurred()) SWIG_fail;
27783 }
27784 resultobj = SWIG_Py_Void();
27785 return resultobj;
27786 fail:
27787 return NULL;
27788 }
27789
27790
27791 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27792 PyObject *resultobj = 0;
27793 wxPyApp *arg1 = (wxPyApp *) 0 ;
27794 bool result;
27795 void *argp1 = 0 ;
27796 int res1 = 0 ;
27797 PyObject *swig_obj[1] ;
27798
27799 if (!args) SWIG_fail;
27800 swig_obj[0] = args;
27801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27802 if (!SWIG_IsOK(res1)) {
27803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27804 }
27805 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27806 {
27807 PyThreadState* __tstate = wxPyBeginAllowThreads();
27808 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27809 wxPyEndAllowThreads(__tstate);
27810 if (PyErr_Occurred()) SWIG_fail;
27811 }
27812 {
27813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27814 }
27815 return resultobj;
27816 fail:
27817 return NULL;
27818 }
27819
27820
27821 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27822 PyObject *resultobj = 0;
27823 wxPyApp *arg1 = (wxPyApp *) 0 ;
27824 bool arg2 ;
27825 void *argp1 = 0 ;
27826 int res1 = 0 ;
27827 bool val2 ;
27828 int ecode2 = 0 ;
27829 PyObject * obj0 = 0 ;
27830 PyObject * obj1 = 0 ;
27831 char * kwnames[] = {
27832 (char *) "self",(char *) "flag", NULL
27833 };
27834
27835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27837 if (!SWIG_IsOK(res1)) {
27838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27839 }
27840 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27841 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27842 if (!SWIG_IsOK(ecode2)) {
27843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27844 }
27845 arg2 = static_cast< bool >(val2);
27846 {
27847 PyThreadState* __tstate = wxPyBeginAllowThreads();
27848 (arg1)->SetUseBestVisual(arg2);
27849 wxPyEndAllowThreads(__tstate);
27850 if (PyErr_Occurred()) SWIG_fail;
27851 }
27852 resultobj = SWIG_Py_Void();
27853 return resultobj;
27854 fail:
27855 return NULL;
27856 }
27857
27858
27859 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27860 PyObject *resultobj = 0;
27861 wxPyApp *arg1 = (wxPyApp *) 0 ;
27862 bool result;
27863 void *argp1 = 0 ;
27864 int res1 = 0 ;
27865 PyObject *swig_obj[1] ;
27866
27867 if (!args) SWIG_fail;
27868 swig_obj[0] = args;
27869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27870 if (!SWIG_IsOK(res1)) {
27871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27872 }
27873 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27874 {
27875 PyThreadState* __tstate = wxPyBeginAllowThreads();
27876 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27877 wxPyEndAllowThreads(__tstate);
27878 if (PyErr_Occurred()) SWIG_fail;
27879 }
27880 {
27881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27882 }
27883 return resultobj;
27884 fail:
27885 return NULL;
27886 }
27887
27888
27889 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27890 PyObject *resultobj = 0;
27891 wxPyApp *arg1 = (wxPyApp *) 0 ;
27892 int arg2 ;
27893 void *argp1 = 0 ;
27894 int res1 = 0 ;
27895 int val2 ;
27896 int ecode2 = 0 ;
27897 PyObject * obj0 = 0 ;
27898 PyObject * obj1 = 0 ;
27899 char * kwnames[] = {
27900 (char *) "self",(char *) "mode", NULL
27901 };
27902
27903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27905 if (!SWIG_IsOK(res1)) {
27906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27907 }
27908 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27909 ecode2 = SWIG_AsVal_int(obj1, &val2);
27910 if (!SWIG_IsOK(ecode2)) {
27911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27912 }
27913 arg2 = static_cast< int >(val2);
27914 {
27915 PyThreadState* __tstate = wxPyBeginAllowThreads();
27916 (arg1)->SetPrintMode(arg2);
27917 wxPyEndAllowThreads(__tstate);
27918 if (PyErr_Occurred()) SWIG_fail;
27919 }
27920 resultobj = SWIG_Py_Void();
27921 return resultobj;
27922 fail:
27923 return NULL;
27924 }
27925
27926
27927 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27928 PyObject *resultobj = 0;
27929 wxPyApp *arg1 = (wxPyApp *) 0 ;
27930 int result;
27931 void *argp1 = 0 ;
27932 int res1 = 0 ;
27933 PyObject *swig_obj[1] ;
27934
27935 if (!args) SWIG_fail;
27936 swig_obj[0] = args;
27937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27938 if (!SWIG_IsOK(res1)) {
27939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27940 }
27941 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27942 {
27943 PyThreadState* __tstate = wxPyBeginAllowThreads();
27944 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27945 wxPyEndAllowThreads(__tstate);
27946 if (PyErr_Occurred()) SWIG_fail;
27947 }
27948 resultobj = SWIG_From_int(static_cast< int >(result));
27949 return resultobj;
27950 fail:
27951 return NULL;
27952 }
27953
27954
27955 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27956 PyObject *resultobj = 0;
27957 wxPyApp *arg1 = (wxPyApp *) 0 ;
27958 int arg2 ;
27959 void *argp1 = 0 ;
27960 int res1 = 0 ;
27961 int val2 ;
27962 int ecode2 = 0 ;
27963 PyObject * obj0 = 0 ;
27964 PyObject * obj1 = 0 ;
27965 char * kwnames[] = {
27966 (char *) "self",(char *) "mode", NULL
27967 };
27968
27969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27971 if (!SWIG_IsOK(res1)) {
27972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27973 }
27974 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27975 ecode2 = SWIG_AsVal_int(obj1, &val2);
27976 if (!SWIG_IsOK(ecode2)) {
27977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27978 }
27979 arg2 = static_cast< int >(val2);
27980 {
27981 PyThreadState* __tstate = wxPyBeginAllowThreads();
27982 (arg1)->SetAssertMode(arg2);
27983 wxPyEndAllowThreads(__tstate);
27984 if (PyErr_Occurred()) SWIG_fail;
27985 }
27986 resultobj = SWIG_Py_Void();
27987 return resultobj;
27988 fail:
27989 return NULL;
27990 }
27991
27992
27993 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27994 PyObject *resultobj = 0;
27995 wxPyApp *arg1 = (wxPyApp *) 0 ;
27996 int result;
27997 void *argp1 = 0 ;
27998 int res1 = 0 ;
27999 PyObject *swig_obj[1] ;
28000
28001 if (!args) SWIG_fail;
28002 swig_obj[0] = args;
28003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28004 if (!SWIG_IsOK(res1)) {
28005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28006 }
28007 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 result = (int)(arg1)->GetAssertMode();
28011 wxPyEndAllowThreads(__tstate);
28012 if (PyErr_Occurred()) SWIG_fail;
28013 }
28014 resultobj = SWIG_From_int(static_cast< int >(result));
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28022 PyObject *resultobj = 0;
28023 bool result;
28024
28025 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28026 {
28027 PyThreadState* __tstate = wxPyBeginAllowThreads();
28028 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28029 wxPyEndAllowThreads(__tstate);
28030 if (PyErr_Occurred()) SWIG_fail;
28031 }
28032 {
28033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28034 }
28035 return resultobj;
28036 fail:
28037 return NULL;
28038 }
28039
28040
28041 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28042 PyObject *resultobj = 0;
28043 long result;
28044
28045 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28046 {
28047 PyThreadState* __tstate = wxPyBeginAllowThreads();
28048 result = (long)wxPyApp::GetMacAboutMenuItemId();
28049 wxPyEndAllowThreads(__tstate);
28050 if (PyErr_Occurred()) SWIG_fail;
28051 }
28052 resultobj = SWIG_From_long(static_cast< long >(result));
28053 return resultobj;
28054 fail:
28055 return NULL;
28056 }
28057
28058
28059 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28060 PyObject *resultobj = 0;
28061 long result;
28062
28063 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28064 {
28065 PyThreadState* __tstate = wxPyBeginAllowThreads();
28066 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28067 wxPyEndAllowThreads(__tstate);
28068 if (PyErr_Occurred()) SWIG_fail;
28069 }
28070 resultobj = SWIG_From_long(static_cast< long >(result));
28071 return resultobj;
28072 fail:
28073 return NULL;
28074 }
28075
28076
28077 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28078 PyObject *resultobj = 0;
28079 long result;
28080
28081 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28082 {
28083 PyThreadState* __tstate = wxPyBeginAllowThreads();
28084 result = (long)wxPyApp::GetMacExitMenuItemId();
28085 wxPyEndAllowThreads(__tstate);
28086 if (PyErr_Occurred()) SWIG_fail;
28087 }
28088 resultobj = SWIG_From_long(static_cast< long >(result));
28089 return resultobj;
28090 fail:
28091 return NULL;
28092 }
28093
28094
28095 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28096 PyObject *resultobj = 0;
28097 wxString result;
28098
28099 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28100 {
28101 PyThreadState* __tstate = wxPyBeginAllowThreads();
28102 result = wxPyApp::GetMacHelpMenuTitleName();
28103 wxPyEndAllowThreads(__tstate);
28104 if (PyErr_Occurred()) SWIG_fail;
28105 }
28106 {
28107 #if wxUSE_UNICODE
28108 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28109 #else
28110 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28111 #endif
28112 }
28113 return resultobj;
28114 fail:
28115 return NULL;
28116 }
28117
28118
28119 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28120 PyObject *resultobj = 0;
28121 bool arg1 ;
28122 bool val1 ;
28123 int ecode1 = 0 ;
28124 PyObject * obj0 = 0 ;
28125 char * kwnames[] = {
28126 (char *) "val", NULL
28127 };
28128
28129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28130 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28131 if (!SWIG_IsOK(ecode1)) {
28132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28133 }
28134 arg1 = static_cast< bool >(val1);
28135 {
28136 PyThreadState* __tstate = wxPyBeginAllowThreads();
28137 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28138 wxPyEndAllowThreads(__tstate);
28139 if (PyErr_Occurred()) SWIG_fail;
28140 }
28141 resultobj = SWIG_Py_Void();
28142 return resultobj;
28143 fail:
28144 return NULL;
28145 }
28146
28147
28148 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28149 PyObject *resultobj = 0;
28150 long arg1 ;
28151 long val1 ;
28152 int ecode1 = 0 ;
28153 PyObject * obj0 = 0 ;
28154 char * kwnames[] = {
28155 (char *) "val", NULL
28156 };
28157
28158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28159 ecode1 = SWIG_AsVal_long(obj0, &val1);
28160 if (!SWIG_IsOK(ecode1)) {
28161 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28162 }
28163 arg1 = static_cast< long >(val1);
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 wxPyApp::SetMacAboutMenuItemId(arg1);
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 resultobj = SWIG_Py_Void();
28171 return resultobj;
28172 fail:
28173 return NULL;
28174 }
28175
28176
28177 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28178 PyObject *resultobj = 0;
28179 long arg1 ;
28180 long val1 ;
28181 int ecode1 = 0 ;
28182 PyObject * obj0 = 0 ;
28183 char * kwnames[] = {
28184 (char *) "val", NULL
28185 };
28186
28187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28188 ecode1 = SWIG_AsVal_long(obj0, &val1);
28189 if (!SWIG_IsOK(ecode1)) {
28190 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28191 }
28192 arg1 = static_cast< long >(val1);
28193 {
28194 PyThreadState* __tstate = wxPyBeginAllowThreads();
28195 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28196 wxPyEndAllowThreads(__tstate);
28197 if (PyErr_Occurred()) SWIG_fail;
28198 }
28199 resultobj = SWIG_Py_Void();
28200 return resultobj;
28201 fail:
28202 return NULL;
28203 }
28204
28205
28206 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28207 PyObject *resultobj = 0;
28208 long arg1 ;
28209 long val1 ;
28210 int ecode1 = 0 ;
28211 PyObject * obj0 = 0 ;
28212 char * kwnames[] = {
28213 (char *) "val", NULL
28214 };
28215
28216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28217 ecode1 = SWIG_AsVal_long(obj0, &val1);
28218 if (!SWIG_IsOK(ecode1)) {
28219 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28220 }
28221 arg1 = static_cast< long >(val1);
28222 {
28223 PyThreadState* __tstate = wxPyBeginAllowThreads();
28224 wxPyApp::SetMacExitMenuItemId(arg1);
28225 wxPyEndAllowThreads(__tstate);
28226 if (PyErr_Occurred()) SWIG_fail;
28227 }
28228 resultobj = SWIG_Py_Void();
28229 return resultobj;
28230 fail:
28231 return NULL;
28232 }
28233
28234
28235 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28236 PyObject *resultobj = 0;
28237 wxString *arg1 = 0 ;
28238 bool temp1 = false ;
28239 PyObject * obj0 = 0 ;
28240 char * kwnames[] = {
28241 (char *) "val", NULL
28242 };
28243
28244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28245 {
28246 arg1 = wxString_in_helper(obj0);
28247 if (arg1 == NULL) SWIG_fail;
28248 temp1 = true;
28249 }
28250 {
28251 PyThreadState* __tstate = wxPyBeginAllowThreads();
28252 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28253 wxPyEndAllowThreads(__tstate);
28254 if (PyErr_Occurred()) SWIG_fail;
28255 }
28256 resultobj = SWIG_Py_Void();
28257 {
28258 if (temp1)
28259 delete arg1;
28260 }
28261 return resultobj;
28262 fail:
28263 {
28264 if (temp1)
28265 delete arg1;
28266 }
28267 return NULL;
28268 }
28269
28270
28271 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28272 PyObject *resultobj = 0;
28273 wxPyApp *arg1 = (wxPyApp *) 0 ;
28274 void *argp1 = 0 ;
28275 int res1 = 0 ;
28276 PyObject *swig_obj[1] ;
28277
28278 if (!args) SWIG_fail;
28279 swig_obj[0] = args;
28280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28281 if (!SWIG_IsOK(res1)) {
28282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28283 }
28284 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28285 {
28286 PyThreadState* __tstate = wxPyBeginAllowThreads();
28287 (arg1)->_BootstrapApp();
28288 wxPyEndAllowThreads(__tstate);
28289 if (PyErr_Occurred()) SWIG_fail;
28290 }
28291 resultobj = SWIG_Py_Void();
28292 return resultobj;
28293 fail:
28294 return NULL;
28295 }
28296
28297
28298 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28299 PyObject *resultobj = 0;
28300 int result;
28301
28302 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28303 {
28304 PyThreadState* __tstate = wxPyBeginAllowThreads();
28305 result = (int)wxPyApp_GetComCtl32Version();
28306 wxPyEndAllowThreads(__tstate);
28307 if (PyErr_Occurred()) SWIG_fail;
28308 }
28309 resultobj = SWIG_From_int(static_cast< int >(result));
28310 return resultobj;
28311 fail:
28312 return NULL;
28313 }
28314
28315
28316 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28317 PyObject *obj;
28318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28319 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28320 return SWIG_Py_Void();
28321 }
28322
28323 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28324 return SWIG_Python_InitShadowInstance(args);
28325 }
28326
28327 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28328 PyObject *resultobj = 0;
28329
28330 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28331 {
28332 PyThreadState* __tstate = wxPyBeginAllowThreads();
28333 wxExit();
28334 wxPyEndAllowThreads(__tstate);
28335 if (PyErr_Occurred()) SWIG_fail;
28336 }
28337 resultobj = SWIG_Py_Void();
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28345 PyObject *resultobj = 0;
28346 bool result;
28347
28348 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28349 {
28350 PyThreadState* __tstate = wxPyBeginAllowThreads();
28351 result = (bool)wxYield();
28352 wxPyEndAllowThreads(__tstate);
28353 if (PyErr_Occurred()) SWIG_fail;
28354 }
28355 {
28356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28357 }
28358 return resultobj;
28359 fail:
28360 return NULL;
28361 }
28362
28363
28364 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28365 PyObject *resultobj = 0;
28366 bool result;
28367
28368 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28369 {
28370 PyThreadState* __tstate = wxPyBeginAllowThreads();
28371 result = (bool)wxYieldIfNeeded();
28372 wxPyEndAllowThreads(__tstate);
28373 if (PyErr_Occurred()) SWIG_fail;
28374 }
28375 {
28376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28377 }
28378 return resultobj;
28379 fail:
28380 return NULL;
28381 }
28382
28383
28384 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28385 PyObject *resultobj = 0;
28386 wxWindow *arg1 = (wxWindow *) NULL ;
28387 bool arg2 = (bool) false ;
28388 bool result;
28389 void *argp1 = 0 ;
28390 int res1 = 0 ;
28391 bool val2 ;
28392 int ecode2 = 0 ;
28393 PyObject * obj0 = 0 ;
28394 PyObject * obj1 = 0 ;
28395 char * kwnames[] = {
28396 (char *) "win",(char *) "onlyIfNeeded", NULL
28397 };
28398
28399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28400 if (obj0) {
28401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28402 if (!SWIG_IsOK(res1)) {
28403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28404 }
28405 arg1 = reinterpret_cast< wxWindow * >(argp1);
28406 }
28407 if (obj1) {
28408 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28409 if (!SWIG_IsOK(ecode2)) {
28410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28411 }
28412 arg2 = static_cast< bool >(val2);
28413 }
28414 {
28415 PyThreadState* __tstate = wxPyBeginAllowThreads();
28416 result = (bool)wxSafeYield(arg1,arg2);
28417 wxPyEndAllowThreads(__tstate);
28418 if (PyErr_Occurred()) SWIG_fail;
28419 }
28420 {
28421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28422 }
28423 return resultobj;
28424 fail:
28425 return NULL;
28426 }
28427
28428
28429 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28430 PyObject *resultobj = 0;
28431
28432 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28433 {
28434 PyThreadState* __tstate = wxPyBeginAllowThreads();
28435 wxWakeUpIdle();
28436 wxPyEndAllowThreads(__tstate);
28437 if (PyErr_Occurred()) SWIG_fail;
28438 }
28439 resultobj = SWIG_Py_Void();
28440 return resultobj;
28441 fail:
28442 return NULL;
28443 }
28444
28445
28446 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28447 PyObject *resultobj = 0;
28448 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28449 wxEvent *arg2 = 0 ;
28450 void *argp1 = 0 ;
28451 int res1 = 0 ;
28452 void *argp2 = 0 ;
28453 int res2 = 0 ;
28454 PyObject * obj0 = 0 ;
28455 PyObject * obj1 = 0 ;
28456 char * kwnames[] = {
28457 (char *) "dest",(char *) "event", NULL
28458 };
28459
28460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28462 if (!SWIG_IsOK(res1)) {
28463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28464 }
28465 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28466 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28467 if (!SWIG_IsOK(res2)) {
28468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28469 }
28470 if (!argp2) {
28471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28472 }
28473 arg2 = reinterpret_cast< wxEvent * >(argp2);
28474 {
28475 PyThreadState* __tstate = wxPyBeginAllowThreads();
28476 wxPostEvent(arg1,*arg2);
28477 wxPyEndAllowThreads(__tstate);
28478 if (PyErr_Occurred()) SWIG_fail;
28479 }
28480 resultobj = SWIG_Py_Void();
28481 return resultobj;
28482 fail:
28483 return NULL;
28484 }
28485
28486
28487 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28488 PyObject *resultobj = 0;
28489
28490 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28491 {
28492 PyThreadState* __tstate = wxPyBeginAllowThreads();
28493 wxApp_CleanUp();
28494 wxPyEndAllowThreads(__tstate);
28495 if (PyErr_Occurred()) SWIG_fail;
28496 }
28497 resultobj = SWIG_Py_Void();
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28505 PyObject *resultobj = 0;
28506 wxPyApp *result = 0 ;
28507
28508 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28509 {
28510 PyThreadState* __tstate = wxPyBeginAllowThreads();
28511 result = (wxPyApp *)wxPyGetApp();
28512 wxPyEndAllowThreads(__tstate);
28513 if (PyErr_Occurred()) SWIG_fail;
28514 }
28515 {
28516 resultobj = wxPyMake_wxObject(result, 0);
28517 }
28518 return resultobj;
28519 fail:
28520 return NULL;
28521 }
28522
28523
28524 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28525 PyObject *resultobj = 0;
28526 char *arg1 = (char *) 0 ;
28527 int res1 ;
28528 char *buf1 = 0 ;
28529 int alloc1 = 0 ;
28530 PyObject * obj0 = 0 ;
28531 char * kwnames[] = {
28532 (char *) "encoding", NULL
28533 };
28534
28535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28536 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28537 if (!SWIG_IsOK(res1)) {
28538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28539 }
28540 arg1 = buf1;
28541 {
28542 PyThreadState* __tstate = wxPyBeginAllowThreads();
28543 wxSetDefaultPyEncoding((char const *)arg1);
28544 wxPyEndAllowThreads(__tstate);
28545 if (PyErr_Occurred()) SWIG_fail;
28546 }
28547 resultobj = SWIG_Py_Void();
28548 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28549 return resultobj;
28550 fail:
28551 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28552 return NULL;
28553 }
28554
28555
28556 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28557 PyObject *resultobj = 0;
28558 char *result = 0 ;
28559
28560 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28561 {
28562 PyThreadState* __tstate = wxPyBeginAllowThreads();
28563 result = (char *)wxGetDefaultPyEncoding();
28564 wxPyEndAllowThreads(__tstate);
28565 if (PyErr_Occurred()) SWIG_fail;
28566 }
28567 resultobj = SWIG_FromCharPtr(result);
28568 return resultobj;
28569 fail:
28570 return NULL;
28571 }
28572
28573
28574 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28575 PyObject *resultobj = 0;
28576 wxEventLoop *result = 0 ;
28577
28578 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28579 {
28580 PyThreadState* __tstate = wxPyBeginAllowThreads();
28581 result = (wxEventLoop *)new wxEventLoop();
28582 wxPyEndAllowThreads(__tstate);
28583 if (PyErr_Occurred()) SWIG_fail;
28584 }
28585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28586 return resultobj;
28587 fail:
28588 return NULL;
28589 }
28590
28591
28592 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28593 PyObject *resultobj = 0;
28594 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28595 void *argp1 = 0 ;
28596 int res1 = 0 ;
28597 PyObject *swig_obj[1] ;
28598
28599 if (!args) SWIG_fail;
28600 swig_obj[0] = args;
28601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28602 if (!SWIG_IsOK(res1)) {
28603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28604 }
28605 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28606 {
28607 PyThreadState* __tstate = wxPyBeginAllowThreads();
28608 delete arg1;
28609
28610 wxPyEndAllowThreads(__tstate);
28611 if (PyErr_Occurred()) SWIG_fail;
28612 }
28613 resultobj = SWIG_Py_Void();
28614 return resultobj;
28615 fail:
28616 return NULL;
28617 }
28618
28619
28620 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28621 PyObject *resultobj = 0;
28622 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28623 int result;
28624 void *argp1 = 0 ;
28625 int res1 = 0 ;
28626 PyObject *swig_obj[1] ;
28627
28628 if (!args) SWIG_fail;
28629 swig_obj[0] = args;
28630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28631 if (!SWIG_IsOK(res1)) {
28632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28633 }
28634 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28635 {
28636 PyThreadState* __tstate = wxPyBeginAllowThreads();
28637 result = (int)(arg1)->Run();
28638 wxPyEndAllowThreads(__tstate);
28639 if (PyErr_Occurred()) SWIG_fail;
28640 }
28641 resultobj = SWIG_From_int(static_cast< int >(result));
28642 return resultobj;
28643 fail:
28644 return NULL;
28645 }
28646
28647
28648 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28649 PyObject *resultobj = 0;
28650 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28651 int arg2 = (int) 0 ;
28652 void *argp1 = 0 ;
28653 int res1 = 0 ;
28654 int val2 ;
28655 int ecode2 = 0 ;
28656 PyObject * obj0 = 0 ;
28657 PyObject * obj1 = 0 ;
28658 char * kwnames[] = {
28659 (char *) "self",(char *) "rc", NULL
28660 };
28661
28662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28664 if (!SWIG_IsOK(res1)) {
28665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28666 }
28667 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28668 if (obj1) {
28669 ecode2 = SWIG_AsVal_int(obj1, &val2);
28670 if (!SWIG_IsOK(ecode2)) {
28671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28672 }
28673 arg2 = static_cast< int >(val2);
28674 }
28675 {
28676 PyThreadState* __tstate = wxPyBeginAllowThreads();
28677 (arg1)->Exit(arg2);
28678 wxPyEndAllowThreads(__tstate);
28679 if (PyErr_Occurred()) SWIG_fail;
28680 }
28681 resultobj = SWIG_Py_Void();
28682 return resultobj;
28683 fail:
28684 return NULL;
28685 }
28686
28687
28688 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28689 PyObject *resultobj = 0;
28690 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28691 bool result;
28692 void *argp1 = 0 ;
28693 int res1 = 0 ;
28694 PyObject *swig_obj[1] ;
28695
28696 if (!args) SWIG_fail;
28697 swig_obj[0] = args;
28698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28699 if (!SWIG_IsOK(res1)) {
28700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28701 }
28702 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28703 {
28704 PyThreadState* __tstate = wxPyBeginAllowThreads();
28705 result = (bool)((wxEventLoop const *)arg1)->Pending();
28706 wxPyEndAllowThreads(__tstate);
28707 if (PyErr_Occurred()) SWIG_fail;
28708 }
28709 {
28710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28711 }
28712 return resultobj;
28713 fail:
28714 return NULL;
28715 }
28716
28717
28718 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28719 PyObject *resultobj = 0;
28720 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28721 bool result;
28722 void *argp1 = 0 ;
28723 int res1 = 0 ;
28724 PyObject *swig_obj[1] ;
28725
28726 if (!args) SWIG_fail;
28727 swig_obj[0] = args;
28728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28729 if (!SWIG_IsOK(res1)) {
28730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28731 }
28732 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28733 {
28734 PyThreadState* __tstate = wxPyBeginAllowThreads();
28735 result = (bool)(arg1)->Dispatch();
28736 wxPyEndAllowThreads(__tstate);
28737 if (PyErr_Occurred()) SWIG_fail;
28738 }
28739 {
28740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28741 }
28742 return resultobj;
28743 fail:
28744 return NULL;
28745 }
28746
28747
28748 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28749 PyObject *resultobj = 0;
28750 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28751 bool result;
28752 void *argp1 = 0 ;
28753 int res1 = 0 ;
28754 PyObject *swig_obj[1] ;
28755
28756 if (!args) SWIG_fail;
28757 swig_obj[0] = args;
28758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28759 if (!SWIG_IsOK(res1)) {
28760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28761 }
28762 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28763 {
28764 PyThreadState* __tstate = wxPyBeginAllowThreads();
28765 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 {
28770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28771 }
28772 return resultobj;
28773 fail:
28774 return NULL;
28775 }
28776
28777
28778 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28779 PyObject *resultobj = 0;
28780 wxEventLoop *result = 0 ;
28781
28782 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28783 {
28784 PyThreadState* __tstate = wxPyBeginAllowThreads();
28785 result = (wxEventLoop *)wxEventLoop::GetActive();
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28790 return resultobj;
28791 fail:
28792 return NULL;
28793 }
28794
28795
28796 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28797 PyObject *resultobj = 0;
28798 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28799 void *argp1 = 0 ;
28800 int res1 = 0 ;
28801 PyObject * obj0 = 0 ;
28802 char * kwnames[] = {
28803 (char *) "loop", NULL
28804 };
28805
28806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28808 if (!SWIG_IsOK(res1)) {
28809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28810 }
28811 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28812 {
28813 PyThreadState* __tstate = wxPyBeginAllowThreads();
28814 wxEventLoop::SetActive(arg1);
28815 wxPyEndAllowThreads(__tstate);
28816 if (PyErr_Occurred()) SWIG_fail;
28817 }
28818 resultobj = SWIG_Py_Void();
28819 return resultobj;
28820 fail:
28821 return NULL;
28822 }
28823
28824
28825 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28826 PyObject *obj;
28827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28828 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28829 return SWIG_Py_Void();
28830 }
28831
28832 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28833 return SWIG_Python_InitShadowInstance(args);
28834 }
28835
28836 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28837 PyObject *resultobj = 0;
28838 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28839 wxEventLoopActivator *result = 0 ;
28840 void *argp1 = 0 ;
28841 int res1 = 0 ;
28842 PyObject * obj0 = 0 ;
28843 char * kwnames[] = {
28844 (char *) "evtLoop", NULL
28845 };
28846
28847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28849 if (!SWIG_IsOK(res1)) {
28850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28851 }
28852 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28853 {
28854 PyThreadState* __tstate = wxPyBeginAllowThreads();
28855 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28856 wxPyEndAllowThreads(__tstate);
28857 if (PyErr_Occurred()) SWIG_fail;
28858 }
28859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28860 return resultobj;
28861 fail:
28862 return NULL;
28863 }
28864
28865
28866 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28867 PyObject *resultobj = 0;
28868 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28869 void *argp1 = 0 ;
28870 int res1 = 0 ;
28871 PyObject *swig_obj[1] ;
28872
28873 if (!args) SWIG_fail;
28874 swig_obj[0] = args;
28875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28876 if (!SWIG_IsOK(res1)) {
28877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28878 }
28879 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28880 {
28881 PyThreadState* __tstate = wxPyBeginAllowThreads();
28882 delete arg1;
28883
28884 wxPyEndAllowThreads(__tstate);
28885 if (PyErr_Occurred()) SWIG_fail;
28886 }
28887 resultobj = SWIG_Py_Void();
28888 return resultobj;
28889 fail:
28890 return NULL;
28891 }
28892
28893
28894 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28895 PyObject *obj;
28896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28897 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28898 return SWIG_Py_Void();
28899 }
28900
28901 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28902 return SWIG_Python_InitShadowInstance(args);
28903 }
28904
28905 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28906 PyObject *resultobj = 0;
28907 int arg1 = (int) 0 ;
28908 int arg2 = (int) 0 ;
28909 int arg3 = (int) 0 ;
28910 wxAcceleratorEntry *result = 0 ;
28911 int val1 ;
28912 int ecode1 = 0 ;
28913 int val2 ;
28914 int ecode2 = 0 ;
28915 int val3 ;
28916 int ecode3 = 0 ;
28917 PyObject * obj0 = 0 ;
28918 PyObject * obj1 = 0 ;
28919 PyObject * obj2 = 0 ;
28920 char * kwnames[] = {
28921 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28922 };
28923
28924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28925 if (obj0) {
28926 ecode1 = SWIG_AsVal_int(obj0, &val1);
28927 if (!SWIG_IsOK(ecode1)) {
28928 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28929 }
28930 arg1 = static_cast< int >(val1);
28931 }
28932 if (obj1) {
28933 ecode2 = SWIG_AsVal_int(obj1, &val2);
28934 if (!SWIG_IsOK(ecode2)) {
28935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28936 }
28937 arg2 = static_cast< int >(val2);
28938 }
28939 if (obj2) {
28940 ecode3 = SWIG_AsVal_int(obj2, &val3);
28941 if (!SWIG_IsOK(ecode3)) {
28942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28943 }
28944 arg3 = static_cast< int >(val3);
28945 }
28946 {
28947 PyThreadState* __tstate = wxPyBeginAllowThreads();
28948 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28949 wxPyEndAllowThreads(__tstate);
28950 if (PyErr_Occurred()) SWIG_fail;
28951 }
28952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28953 return resultobj;
28954 fail:
28955 return NULL;
28956 }
28957
28958
28959 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28960 PyObject *resultobj = 0;
28961 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28962 void *argp1 = 0 ;
28963 int res1 = 0 ;
28964 PyObject *swig_obj[1] ;
28965
28966 if (!args) SWIG_fail;
28967 swig_obj[0] = args;
28968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28969 if (!SWIG_IsOK(res1)) {
28970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28971 }
28972 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28973 {
28974 PyThreadState* __tstate = wxPyBeginAllowThreads();
28975 delete arg1;
28976
28977 wxPyEndAllowThreads(__tstate);
28978 if (PyErr_Occurred()) SWIG_fail;
28979 }
28980 resultobj = SWIG_Py_Void();
28981 return resultobj;
28982 fail:
28983 return NULL;
28984 }
28985
28986
28987 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28988 PyObject *resultobj = 0;
28989 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28990 int arg2 ;
28991 int arg3 ;
28992 int arg4 ;
28993 void *argp1 = 0 ;
28994 int res1 = 0 ;
28995 int val2 ;
28996 int ecode2 = 0 ;
28997 int val3 ;
28998 int ecode3 = 0 ;
28999 int val4 ;
29000 int ecode4 = 0 ;
29001 PyObject * obj0 = 0 ;
29002 PyObject * obj1 = 0 ;
29003 PyObject * obj2 = 0 ;
29004 PyObject * obj3 = 0 ;
29005 char * kwnames[] = {
29006 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29007 };
29008
29009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29011 if (!SWIG_IsOK(res1)) {
29012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29013 }
29014 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29015 ecode2 = SWIG_AsVal_int(obj1, &val2);
29016 if (!SWIG_IsOK(ecode2)) {
29017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29018 }
29019 arg2 = static_cast< int >(val2);
29020 ecode3 = SWIG_AsVal_int(obj2, &val3);
29021 if (!SWIG_IsOK(ecode3)) {
29022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29023 }
29024 arg3 = static_cast< int >(val3);
29025 ecode4 = SWIG_AsVal_int(obj3, &val4);
29026 if (!SWIG_IsOK(ecode4)) {
29027 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29028 }
29029 arg4 = static_cast< int >(val4);
29030 {
29031 PyThreadState* __tstate = wxPyBeginAllowThreads();
29032 (arg1)->Set(arg2,arg3,arg4);
29033 wxPyEndAllowThreads(__tstate);
29034 if (PyErr_Occurred()) SWIG_fail;
29035 }
29036 resultobj = SWIG_Py_Void();
29037 return resultobj;
29038 fail:
29039 return NULL;
29040 }
29041
29042
29043 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29044 PyObject *resultobj = 0;
29045 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29046 int result;
29047 void *argp1 = 0 ;
29048 int res1 = 0 ;
29049 PyObject *swig_obj[1] ;
29050
29051 if (!args) SWIG_fail;
29052 swig_obj[0] = args;
29053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29054 if (!SWIG_IsOK(res1)) {
29055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29056 }
29057 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29058 {
29059 PyThreadState* __tstate = wxPyBeginAllowThreads();
29060 result = (int)(arg1)->GetFlags();
29061 wxPyEndAllowThreads(__tstate);
29062 if (PyErr_Occurred()) SWIG_fail;
29063 }
29064 resultobj = SWIG_From_int(static_cast< int >(result));
29065 return resultobj;
29066 fail:
29067 return NULL;
29068 }
29069
29070
29071 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29072 PyObject *resultobj = 0;
29073 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29074 int result;
29075 void *argp1 = 0 ;
29076 int res1 = 0 ;
29077 PyObject *swig_obj[1] ;
29078
29079 if (!args) SWIG_fail;
29080 swig_obj[0] = args;
29081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29082 if (!SWIG_IsOK(res1)) {
29083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29084 }
29085 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29086 {
29087 PyThreadState* __tstate = wxPyBeginAllowThreads();
29088 result = (int)(arg1)->GetKeyCode();
29089 wxPyEndAllowThreads(__tstate);
29090 if (PyErr_Occurred()) SWIG_fail;
29091 }
29092 resultobj = SWIG_From_int(static_cast< int >(result));
29093 return resultobj;
29094 fail:
29095 return NULL;
29096 }
29097
29098
29099 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29100 PyObject *resultobj = 0;
29101 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29102 int result;
29103 void *argp1 = 0 ;
29104 int res1 = 0 ;
29105 PyObject *swig_obj[1] ;
29106
29107 if (!args) SWIG_fail;
29108 swig_obj[0] = args;
29109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29110 if (!SWIG_IsOK(res1)) {
29111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29112 }
29113 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29114 {
29115 PyThreadState* __tstate = wxPyBeginAllowThreads();
29116 result = (int)(arg1)->GetCommand();
29117 wxPyEndAllowThreads(__tstate);
29118 if (PyErr_Occurred()) SWIG_fail;
29119 }
29120 resultobj = SWIG_From_int(static_cast< int >(result));
29121 return resultobj;
29122 fail:
29123 return NULL;
29124 }
29125
29126
29127 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29128 PyObject *obj;
29129 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29130 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29131 return SWIG_Py_Void();
29132 }
29133
29134 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29135 return SWIG_Python_InitShadowInstance(args);
29136 }
29137
29138 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29139 PyObject *resultobj = 0;
29140 int arg1 ;
29141 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29142 wxAcceleratorTable *result = 0 ;
29143 PyObject * obj0 = 0 ;
29144 char * kwnames[] = {
29145 (char *) "n", NULL
29146 };
29147
29148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29149 {
29150 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29151 if (arg2) arg1 = PyList_Size(obj0);
29152 else arg1 = 0;
29153 }
29154 {
29155 PyThreadState* __tstate = wxPyBeginAllowThreads();
29156 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29157 wxPyEndAllowThreads(__tstate);
29158 if (PyErr_Occurred()) SWIG_fail;
29159 }
29160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29161 return resultobj;
29162 fail:
29163 return NULL;
29164 }
29165
29166
29167 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29168 PyObject *resultobj = 0;
29169 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29170 void *argp1 = 0 ;
29171 int res1 = 0 ;
29172 PyObject *swig_obj[1] ;
29173
29174 if (!args) SWIG_fail;
29175 swig_obj[0] = args;
29176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29177 if (!SWIG_IsOK(res1)) {
29178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29179 }
29180 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29181 {
29182 PyThreadState* __tstate = wxPyBeginAllowThreads();
29183 delete arg1;
29184
29185 wxPyEndAllowThreads(__tstate);
29186 if (PyErr_Occurred()) SWIG_fail;
29187 }
29188 resultobj = SWIG_Py_Void();
29189 return resultobj;
29190 fail:
29191 return NULL;
29192 }
29193
29194
29195 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29196 PyObject *resultobj = 0;
29197 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29198 bool result;
29199 void *argp1 = 0 ;
29200 int res1 = 0 ;
29201 PyObject *swig_obj[1] ;
29202
29203 if (!args) SWIG_fail;
29204 swig_obj[0] = args;
29205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29206 if (!SWIG_IsOK(res1)) {
29207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29208 }
29209 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29210 {
29211 PyThreadState* __tstate = wxPyBeginAllowThreads();
29212 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29213 wxPyEndAllowThreads(__tstate);
29214 if (PyErr_Occurred()) SWIG_fail;
29215 }
29216 {
29217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29218 }
29219 return resultobj;
29220 fail:
29221 return NULL;
29222 }
29223
29224
29225 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29226 PyObject *obj;
29227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29228 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29229 return SWIG_Py_Void();
29230 }
29231
29232 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29233 return SWIG_Python_InitShadowInstance(args);
29234 }
29235
29236 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29237 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29238 return 1;
29239 }
29240
29241
29242 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29243 PyObject *pyobj = 0;
29244
29245 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29246 return pyobj;
29247 }
29248
29249
29250 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29251 PyObject *resultobj = 0;
29252 wxString *arg1 = 0 ;
29253 wxAcceleratorEntry *result = 0 ;
29254 bool temp1 = false ;
29255 PyObject * obj0 = 0 ;
29256 char * kwnames[] = {
29257 (char *) "label", NULL
29258 };
29259
29260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29261 {
29262 arg1 = wxString_in_helper(obj0);
29263 if (arg1 == NULL) SWIG_fail;
29264 temp1 = true;
29265 }
29266 {
29267 PyThreadState* __tstate = wxPyBeginAllowThreads();
29268 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29269 wxPyEndAllowThreads(__tstate);
29270 if (PyErr_Occurred()) SWIG_fail;
29271 }
29272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29273 {
29274 if (temp1)
29275 delete arg1;
29276 }
29277 return resultobj;
29278 fail:
29279 {
29280 if (temp1)
29281 delete arg1;
29282 }
29283 return NULL;
29284 }
29285
29286
29287 SWIGINTERN int PanelNameStr_set(PyObject *) {
29288 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29289 return 1;
29290 }
29291
29292
29293 SWIGINTERN PyObject *PanelNameStr_get(void) {
29294 PyObject *pyobj = 0;
29295
29296 {
29297 #if wxUSE_UNICODE
29298 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29299 #else
29300 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29301 #endif
29302 }
29303 return pyobj;
29304 }
29305
29306
29307 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29308 PyObject *resultobj = 0;
29309 wxVisualAttributes *result = 0 ;
29310
29311 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29312 {
29313 PyThreadState* __tstate = wxPyBeginAllowThreads();
29314 result = (wxVisualAttributes *)new_wxVisualAttributes();
29315 wxPyEndAllowThreads(__tstate);
29316 if (PyErr_Occurred()) SWIG_fail;
29317 }
29318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29319 return resultobj;
29320 fail:
29321 return NULL;
29322 }
29323
29324
29325 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29326 PyObject *resultobj = 0;
29327 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29328 void *argp1 = 0 ;
29329 int res1 = 0 ;
29330 PyObject *swig_obj[1] ;
29331
29332 if (!args) SWIG_fail;
29333 swig_obj[0] = args;
29334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29335 if (!SWIG_IsOK(res1)) {
29336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29337 }
29338 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29339 {
29340 PyThreadState* __tstate = wxPyBeginAllowThreads();
29341 delete_wxVisualAttributes(arg1);
29342
29343 wxPyEndAllowThreads(__tstate);
29344 if (PyErr_Occurred()) SWIG_fail;
29345 }
29346 resultobj = SWIG_Py_Void();
29347 return resultobj;
29348 fail:
29349 return NULL;
29350 }
29351
29352
29353 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29354 PyObject *resultobj = 0;
29355 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29356 wxFont *arg2 = (wxFont *) 0 ;
29357 void *argp1 = 0 ;
29358 int res1 = 0 ;
29359 void *argp2 = 0 ;
29360 int res2 = 0 ;
29361 PyObject *swig_obj[2] ;
29362
29363 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29365 if (!SWIG_IsOK(res1)) {
29366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29367 }
29368 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29369 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29370 if (!SWIG_IsOK(res2)) {
29371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29372 }
29373 arg2 = reinterpret_cast< wxFont * >(argp2);
29374 if (arg1) (arg1)->font = *arg2;
29375
29376 resultobj = SWIG_Py_Void();
29377 return resultobj;
29378 fail:
29379 return NULL;
29380 }
29381
29382
29383 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29384 PyObject *resultobj = 0;
29385 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29386 wxFont *result = 0 ;
29387 void *argp1 = 0 ;
29388 int res1 = 0 ;
29389 PyObject *swig_obj[1] ;
29390
29391 if (!args) SWIG_fail;
29392 swig_obj[0] = args;
29393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29394 if (!SWIG_IsOK(res1)) {
29395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29396 }
29397 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29398 result = (wxFont *)& ((arg1)->font);
29399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29400 return resultobj;
29401 fail:
29402 return NULL;
29403 }
29404
29405
29406 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29407 PyObject *resultobj = 0;
29408 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29409 wxColour *arg2 = (wxColour *) 0 ;
29410 void *argp1 = 0 ;
29411 int res1 = 0 ;
29412 void *argp2 = 0 ;
29413 int res2 = 0 ;
29414 PyObject *swig_obj[2] ;
29415
29416 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29418 if (!SWIG_IsOK(res1)) {
29419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29420 }
29421 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29422 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29423 if (!SWIG_IsOK(res2)) {
29424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29425 }
29426 arg2 = reinterpret_cast< wxColour * >(argp2);
29427 if (arg1) (arg1)->colFg = *arg2;
29428
29429 resultobj = SWIG_Py_Void();
29430 return resultobj;
29431 fail:
29432 return NULL;
29433 }
29434
29435
29436 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29437 PyObject *resultobj = 0;
29438 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29439 wxColour *result = 0 ;
29440 void *argp1 = 0 ;
29441 int res1 = 0 ;
29442 PyObject *swig_obj[1] ;
29443
29444 if (!args) SWIG_fail;
29445 swig_obj[0] = args;
29446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29447 if (!SWIG_IsOK(res1)) {
29448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29449 }
29450 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29451 result = (wxColour *)& ((arg1)->colFg);
29452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29453 return resultobj;
29454 fail:
29455 return NULL;
29456 }
29457
29458
29459 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29460 PyObject *resultobj = 0;
29461 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29462 wxColour *arg2 = (wxColour *) 0 ;
29463 void *argp1 = 0 ;
29464 int res1 = 0 ;
29465 void *argp2 = 0 ;
29466 int res2 = 0 ;
29467 PyObject *swig_obj[2] ;
29468
29469 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29471 if (!SWIG_IsOK(res1)) {
29472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29473 }
29474 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29475 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29476 if (!SWIG_IsOK(res2)) {
29477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29478 }
29479 arg2 = reinterpret_cast< wxColour * >(argp2);
29480 if (arg1) (arg1)->colBg = *arg2;
29481
29482 resultobj = SWIG_Py_Void();
29483 return resultobj;
29484 fail:
29485 return NULL;
29486 }
29487
29488
29489 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29490 PyObject *resultobj = 0;
29491 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29492 wxColour *result = 0 ;
29493 void *argp1 = 0 ;
29494 int res1 = 0 ;
29495 PyObject *swig_obj[1] ;
29496
29497 if (!args) SWIG_fail;
29498 swig_obj[0] = args;
29499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29500 if (!SWIG_IsOK(res1)) {
29501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29502 }
29503 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29504 result = (wxColour *)& ((arg1)->colBg);
29505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29506 return resultobj;
29507 fail:
29508 return NULL;
29509 }
29510
29511
29512 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29513 PyObject *obj;
29514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29515 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29516 return SWIG_Py_Void();
29517 }
29518
29519 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29520 return SWIG_Python_InitShadowInstance(args);
29521 }
29522
29523 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29524 PyObject *resultobj = 0;
29525 wxWindow *arg1 = (wxWindow *) 0 ;
29526 int arg2 = (int) (int)-1 ;
29527 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29528 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29529 wxSize const &arg4_defvalue = wxDefaultSize ;
29530 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29531 long arg5 = (long) 0 ;
29532 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29533 wxString *arg6 = (wxString *) &arg6_defvalue ;
29534 wxWindow *result = 0 ;
29535 void *argp1 = 0 ;
29536 int res1 = 0 ;
29537 int val2 ;
29538 int ecode2 = 0 ;
29539 wxPoint temp3 ;
29540 wxSize temp4 ;
29541 long val5 ;
29542 int ecode5 = 0 ;
29543 bool temp6 = false ;
29544 PyObject * obj0 = 0 ;
29545 PyObject * obj1 = 0 ;
29546 PyObject * obj2 = 0 ;
29547 PyObject * obj3 = 0 ;
29548 PyObject * obj4 = 0 ;
29549 PyObject * obj5 = 0 ;
29550 char * kwnames[] = {
29551 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29552 };
29553
29554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29556 if (!SWIG_IsOK(res1)) {
29557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29558 }
29559 arg1 = reinterpret_cast< wxWindow * >(argp1);
29560 if (obj1) {
29561 ecode2 = SWIG_AsVal_int(obj1, &val2);
29562 if (!SWIG_IsOK(ecode2)) {
29563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29564 }
29565 arg2 = static_cast< int >(val2);
29566 }
29567 if (obj2) {
29568 {
29569 arg3 = &temp3;
29570 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29571 }
29572 }
29573 if (obj3) {
29574 {
29575 arg4 = &temp4;
29576 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29577 }
29578 }
29579 if (obj4) {
29580 ecode5 = SWIG_AsVal_long(obj4, &val5);
29581 if (!SWIG_IsOK(ecode5)) {
29582 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29583 }
29584 arg5 = static_cast< long >(val5);
29585 }
29586 if (obj5) {
29587 {
29588 arg6 = wxString_in_helper(obj5);
29589 if (arg6 == NULL) SWIG_fail;
29590 temp6 = true;
29591 }
29592 }
29593 {
29594 if (!wxPyCheckForApp()) SWIG_fail;
29595 PyThreadState* __tstate = wxPyBeginAllowThreads();
29596 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29597 wxPyEndAllowThreads(__tstate);
29598 if (PyErr_Occurred()) SWIG_fail;
29599 }
29600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29601 {
29602 if (temp6)
29603 delete arg6;
29604 }
29605 return resultobj;
29606 fail:
29607 {
29608 if (temp6)
29609 delete arg6;
29610 }
29611 return NULL;
29612 }
29613
29614
29615 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29616 PyObject *resultobj = 0;
29617 wxWindow *result = 0 ;
29618
29619 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29620 {
29621 if (!wxPyCheckForApp()) SWIG_fail;
29622 PyThreadState* __tstate = wxPyBeginAllowThreads();
29623 result = (wxWindow *)new wxWindow();
29624 wxPyEndAllowThreads(__tstate);
29625 if (PyErr_Occurred()) SWIG_fail;
29626 }
29627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29628 return resultobj;
29629 fail:
29630 return NULL;
29631 }
29632
29633
29634 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29635 PyObject *resultobj = 0;
29636 wxWindow *arg1 = (wxWindow *) 0 ;
29637 wxWindow *arg2 = (wxWindow *) 0 ;
29638 int arg3 = (int) (int)-1 ;
29639 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29640 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29641 wxSize const &arg5_defvalue = wxDefaultSize ;
29642 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29643 long arg6 = (long) 0 ;
29644 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29645 wxString *arg7 = (wxString *) &arg7_defvalue ;
29646 bool result;
29647 void *argp1 = 0 ;
29648 int res1 = 0 ;
29649 void *argp2 = 0 ;
29650 int res2 = 0 ;
29651 int val3 ;
29652 int ecode3 = 0 ;
29653 wxPoint temp4 ;
29654 wxSize temp5 ;
29655 long val6 ;
29656 int ecode6 = 0 ;
29657 bool temp7 = false ;
29658 PyObject * obj0 = 0 ;
29659 PyObject * obj1 = 0 ;
29660 PyObject * obj2 = 0 ;
29661 PyObject * obj3 = 0 ;
29662 PyObject * obj4 = 0 ;
29663 PyObject * obj5 = 0 ;
29664 PyObject * obj6 = 0 ;
29665 char * kwnames[] = {
29666 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29667 };
29668
29669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29671 if (!SWIG_IsOK(res1)) {
29672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29673 }
29674 arg1 = reinterpret_cast< wxWindow * >(argp1);
29675 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29676 if (!SWIG_IsOK(res2)) {
29677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29678 }
29679 arg2 = reinterpret_cast< wxWindow * >(argp2);
29680 if (obj2) {
29681 ecode3 = SWIG_AsVal_int(obj2, &val3);
29682 if (!SWIG_IsOK(ecode3)) {
29683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29684 }
29685 arg3 = static_cast< int >(val3);
29686 }
29687 if (obj3) {
29688 {
29689 arg4 = &temp4;
29690 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29691 }
29692 }
29693 if (obj4) {
29694 {
29695 arg5 = &temp5;
29696 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29697 }
29698 }
29699 if (obj5) {
29700 ecode6 = SWIG_AsVal_long(obj5, &val6);
29701 if (!SWIG_IsOK(ecode6)) {
29702 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29703 }
29704 arg6 = static_cast< long >(val6);
29705 }
29706 if (obj6) {
29707 {
29708 arg7 = wxString_in_helper(obj6);
29709 if (arg7 == NULL) SWIG_fail;
29710 temp7 = true;
29711 }
29712 }
29713 {
29714 PyThreadState* __tstate = wxPyBeginAllowThreads();
29715 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29716 wxPyEndAllowThreads(__tstate);
29717 if (PyErr_Occurred()) SWIG_fail;
29718 }
29719 {
29720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29721 }
29722 {
29723 if (temp7)
29724 delete arg7;
29725 }
29726 return resultobj;
29727 fail:
29728 {
29729 if (temp7)
29730 delete arg7;
29731 }
29732 return NULL;
29733 }
29734
29735
29736 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29737 PyObject *resultobj = 0;
29738 wxWindow *arg1 = (wxWindow *) 0 ;
29739 bool arg2 = (bool) false ;
29740 bool result;
29741 void *argp1 = 0 ;
29742 int res1 = 0 ;
29743 bool val2 ;
29744 int ecode2 = 0 ;
29745 PyObject * obj0 = 0 ;
29746 PyObject * obj1 = 0 ;
29747 char * kwnames[] = {
29748 (char *) "self",(char *) "force", NULL
29749 };
29750
29751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29753 if (!SWIG_IsOK(res1)) {
29754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29755 }
29756 arg1 = reinterpret_cast< wxWindow * >(argp1);
29757 if (obj1) {
29758 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29759 if (!SWIG_IsOK(ecode2)) {
29760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29761 }
29762 arg2 = static_cast< bool >(val2);
29763 }
29764 {
29765 PyThreadState* __tstate = wxPyBeginAllowThreads();
29766 result = (bool)(arg1)->Close(arg2);
29767 wxPyEndAllowThreads(__tstate);
29768 if (PyErr_Occurred()) SWIG_fail;
29769 }
29770 {
29771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29772 }
29773 return resultobj;
29774 fail:
29775 return NULL;
29776 }
29777
29778
29779 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29780 PyObject *resultobj = 0;
29781 wxWindow *arg1 = (wxWindow *) 0 ;
29782 bool result;
29783 void *argp1 = 0 ;
29784 int res1 = 0 ;
29785 PyObject *swig_obj[1] ;
29786
29787 if (!args) SWIG_fail;
29788 swig_obj[0] = args;
29789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29790 if (!SWIG_IsOK(res1)) {
29791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29792 }
29793 arg1 = reinterpret_cast< wxWindow * >(argp1);
29794 {
29795 PyThreadState* __tstate = wxPyBeginAllowThreads();
29796 result = (bool)(arg1)->Destroy();
29797 wxPyEndAllowThreads(__tstate);
29798 if (PyErr_Occurred()) SWIG_fail;
29799 }
29800 {
29801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29802 }
29803 return resultobj;
29804 fail:
29805 return NULL;
29806 }
29807
29808
29809 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29810 PyObject *resultobj = 0;
29811 wxWindow *arg1 = (wxWindow *) 0 ;
29812 bool result;
29813 void *argp1 = 0 ;
29814 int res1 = 0 ;
29815 PyObject *swig_obj[1] ;
29816
29817 if (!args) SWIG_fail;
29818 swig_obj[0] = args;
29819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29820 if (!SWIG_IsOK(res1)) {
29821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29822 }
29823 arg1 = reinterpret_cast< wxWindow * >(argp1);
29824 {
29825 PyThreadState* __tstate = wxPyBeginAllowThreads();
29826 result = (bool)(arg1)->DestroyChildren();
29827 wxPyEndAllowThreads(__tstate);
29828 if (PyErr_Occurred()) SWIG_fail;
29829 }
29830 {
29831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29832 }
29833 return resultobj;
29834 fail:
29835 return NULL;
29836 }
29837
29838
29839 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29840 PyObject *resultobj = 0;
29841 wxWindow *arg1 = (wxWindow *) 0 ;
29842 bool result;
29843 void *argp1 = 0 ;
29844 int res1 = 0 ;
29845 PyObject *swig_obj[1] ;
29846
29847 if (!args) SWIG_fail;
29848 swig_obj[0] = args;
29849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29850 if (!SWIG_IsOK(res1)) {
29851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29852 }
29853 arg1 = reinterpret_cast< wxWindow * >(argp1);
29854 {
29855 PyThreadState* __tstate = wxPyBeginAllowThreads();
29856 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29857 wxPyEndAllowThreads(__tstate);
29858 if (PyErr_Occurred()) SWIG_fail;
29859 }
29860 {
29861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29862 }
29863 return resultobj;
29864 fail:
29865 return NULL;
29866 }
29867
29868
29869 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29870 PyObject *resultobj = 0;
29871 wxWindow *arg1 = (wxWindow *) 0 ;
29872 wxString *arg2 = 0 ;
29873 void *argp1 = 0 ;
29874 int res1 = 0 ;
29875 bool temp2 = false ;
29876 PyObject * obj0 = 0 ;
29877 PyObject * obj1 = 0 ;
29878 char * kwnames[] = {
29879 (char *) "self",(char *) "label", NULL
29880 };
29881
29882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29884 if (!SWIG_IsOK(res1)) {
29885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29886 }
29887 arg1 = reinterpret_cast< wxWindow * >(argp1);
29888 {
29889 arg2 = wxString_in_helper(obj1);
29890 if (arg2 == NULL) SWIG_fail;
29891 temp2 = true;
29892 }
29893 {
29894 PyThreadState* __tstate = wxPyBeginAllowThreads();
29895 (arg1)->SetLabel((wxString const &)*arg2);
29896 wxPyEndAllowThreads(__tstate);
29897 if (PyErr_Occurred()) SWIG_fail;
29898 }
29899 resultobj = SWIG_Py_Void();
29900 {
29901 if (temp2)
29902 delete arg2;
29903 }
29904 return resultobj;
29905 fail:
29906 {
29907 if (temp2)
29908 delete arg2;
29909 }
29910 return NULL;
29911 }
29912
29913
29914 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29915 PyObject *resultobj = 0;
29916 wxWindow *arg1 = (wxWindow *) 0 ;
29917 wxString result;
29918 void *argp1 = 0 ;
29919 int res1 = 0 ;
29920 PyObject *swig_obj[1] ;
29921
29922 if (!args) SWIG_fail;
29923 swig_obj[0] = args;
29924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29925 if (!SWIG_IsOK(res1)) {
29926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29927 }
29928 arg1 = reinterpret_cast< wxWindow * >(argp1);
29929 {
29930 PyThreadState* __tstate = wxPyBeginAllowThreads();
29931 result = ((wxWindow const *)arg1)->GetLabel();
29932 wxPyEndAllowThreads(__tstate);
29933 if (PyErr_Occurred()) SWIG_fail;
29934 }
29935 {
29936 #if wxUSE_UNICODE
29937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29938 #else
29939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29940 #endif
29941 }
29942 return resultobj;
29943 fail:
29944 return NULL;
29945 }
29946
29947
29948 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29949 PyObject *resultobj = 0;
29950 wxWindow *arg1 = (wxWindow *) 0 ;
29951 wxString *arg2 = 0 ;
29952 void *argp1 = 0 ;
29953 int res1 = 0 ;
29954 bool temp2 = false ;
29955 PyObject * obj0 = 0 ;
29956 PyObject * obj1 = 0 ;
29957 char * kwnames[] = {
29958 (char *) "self",(char *) "name", NULL
29959 };
29960
29961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29963 if (!SWIG_IsOK(res1)) {
29964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29965 }
29966 arg1 = reinterpret_cast< wxWindow * >(argp1);
29967 {
29968 arg2 = wxString_in_helper(obj1);
29969 if (arg2 == NULL) SWIG_fail;
29970 temp2 = true;
29971 }
29972 {
29973 PyThreadState* __tstate = wxPyBeginAllowThreads();
29974 (arg1)->SetName((wxString const &)*arg2);
29975 wxPyEndAllowThreads(__tstate);
29976 if (PyErr_Occurred()) SWIG_fail;
29977 }
29978 resultobj = SWIG_Py_Void();
29979 {
29980 if (temp2)
29981 delete arg2;
29982 }
29983 return resultobj;
29984 fail:
29985 {
29986 if (temp2)
29987 delete arg2;
29988 }
29989 return NULL;
29990 }
29991
29992
29993 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29994 PyObject *resultobj = 0;
29995 wxWindow *arg1 = (wxWindow *) 0 ;
29996 wxString result;
29997 void *argp1 = 0 ;
29998 int res1 = 0 ;
29999 PyObject *swig_obj[1] ;
30000
30001 if (!args) SWIG_fail;
30002 swig_obj[0] = args;
30003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30004 if (!SWIG_IsOK(res1)) {
30005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30006 }
30007 arg1 = reinterpret_cast< wxWindow * >(argp1);
30008 {
30009 PyThreadState* __tstate = wxPyBeginAllowThreads();
30010 result = ((wxWindow const *)arg1)->GetName();
30011 wxPyEndAllowThreads(__tstate);
30012 if (PyErr_Occurred()) SWIG_fail;
30013 }
30014 {
30015 #if wxUSE_UNICODE
30016 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30017 #else
30018 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30019 #endif
30020 }
30021 return resultobj;
30022 fail:
30023 return NULL;
30024 }
30025
30026
30027 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30028 PyObject *resultobj = 0;
30029 wxWindow *arg1 = (wxWindow *) 0 ;
30030 wxWindowVariant arg2 ;
30031 void *argp1 = 0 ;
30032 int res1 = 0 ;
30033 int val2 ;
30034 int ecode2 = 0 ;
30035 PyObject * obj0 = 0 ;
30036 PyObject * obj1 = 0 ;
30037 char * kwnames[] = {
30038 (char *) "self",(char *) "variant", NULL
30039 };
30040
30041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30043 if (!SWIG_IsOK(res1)) {
30044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30045 }
30046 arg1 = reinterpret_cast< wxWindow * >(argp1);
30047 ecode2 = SWIG_AsVal_int(obj1, &val2);
30048 if (!SWIG_IsOK(ecode2)) {
30049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30050 }
30051 arg2 = static_cast< wxWindowVariant >(val2);
30052 {
30053 PyThreadState* __tstate = wxPyBeginAllowThreads();
30054 (arg1)->SetWindowVariant(arg2);
30055 wxPyEndAllowThreads(__tstate);
30056 if (PyErr_Occurred()) SWIG_fail;
30057 }
30058 resultobj = SWIG_Py_Void();
30059 return resultobj;
30060 fail:
30061 return NULL;
30062 }
30063
30064
30065 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30066 PyObject *resultobj = 0;
30067 wxWindow *arg1 = (wxWindow *) 0 ;
30068 wxWindowVariant result;
30069 void *argp1 = 0 ;
30070 int res1 = 0 ;
30071 PyObject *swig_obj[1] ;
30072
30073 if (!args) SWIG_fail;
30074 swig_obj[0] = args;
30075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30076 if (!SWIG_IsOK(res1)) {
30077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30078 }
30079 arg1 = reinterpret_cast< wxWindow * >(argp1);
30080 {
30081 PyThreadState* __tstate = wxPyBeginAllowThreads();
30082 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30083 wxPyEndAllowThreads(__tstate);
30084 if (PyErr_Occurred()) SWIG_fail;
30085 }
30086 resultobj = SWIG_From_int(static_cast< int >(result));
30087 return resultobj;
30088 fail:
30089 return NULL;
30090 }
30091
30092
30093 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30094 PyObject *resultobj = 0;
30095 wxWindow *arg1 = (wxWindow *) 0 ;
30096 int arg2 ;
30097 void *argp1 = 0 ;
30098 int res1 = 0 ;
30099 int val2 ;
30100 int ecode2 = 0 ;
30101 PyObject * obj0 = 0 ;
30102 PyObject * obj1 = 0 ;
30103 char * kwnames[] = {
30104 (char *) "self",(char *) "winid", NULL
30105 };
30106
30107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30109 if (!SWIG_IsOK(res1)) {
30110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30111 }
30112 arg1 = reinterpret_cast< wxWindow * >(argp1);
30113 ecode2 = SWIG_AsVal_int(obj1, &val2);
30114 if (!SWIG_IsOK(ecode2)) {
30115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30116 }
30117 arg2 = static_cast< int >(val2);
30118 {
30119 PyThreadState* __tstate = wxPyBeginAllowThreads();
30120 (arg1)->SetId(arg2);
30121 wxPyEndAllowThreads(__tstate);
30122 if (PyErr_Occurred()) SWIG_fail;
30123 }
30124 resultobj = SWIG_Py_Void();
30125 return resultobj;
30126 fail:
30127 return NULL;
30128 }
30129
30130
30131 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30132 PyObject *resultobj = 0;
30133 wxWindow *arg1 = (wxWindow *) 0 ;
30134 int result;
30135 void *argp1 = 0 ;
30136 int res1 = 0 ;
30137 PyObject *swig_obj[1] ;
30138
30139 if (!args) SWIG_fail;
30140 swig_obj[0] = args;
30141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30142 if (!SWIG_IsOK(res1)) {
30143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30144 }
30145 arg1 = reinterpret_cast< wxWindow * >(argp1);
30146 {
30147 PyThreadState* __tstate = wxPyBeginAllowThreads();
30148 result = (int)((wxWindow const *)arg1)->GetId();
30149 wxPyEndAllowThreads(__tstate);
30150 if (PyErr_Occurred()) SWIG_fail;
30151 }
30152 resultobj = SWIG_From_int(static_cast< int >(result));
30153 return resultobj;
30154 fail:
30155 return NULL;
30156 }
30157
30158
30159 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30160 PyObject *resultobj = 0;
30161 int result;
30162
30163 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30164 {
30165 PyThreadState* __tstate = wxPyBeginAllowThreads();
30166 result = (int)wxWindow::NewControlId();
30167 wxPyEndAllowThreads(__tstate);
30168 if (PyErr_Occurred()) SWIG_fail;
30169 }
30170 resultobj = SWIG_From_int(static_cast< int >(result));
30171 return resultobj;
30172 fail:
30173 return NULL;
30174 }
30175
30176
30177 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30178 PyObject *resultobj = 0;
30179 int arg1 ;
30180 int result;
30181 int val1 ;
30182 int ecode1 = 0 ;
30183 PyObject * obj0 = 0 ;
30184 char * kwnames[] = {
30185 (char *) "winid", NULL
30186 };
30187
30188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30189 ecode1 = SWIG_AsVal_int(obj0, &val1);
30190 if (!SWIG_IsOK(ecode1)) {
30191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30192 }
30193 arg1 = static_cast< int >(val1);
30194 {
30195 PyThreadState* __tstate = wxPyBeginAllowThreads();
30196 result = (int)wxWindow::NextControlId(arg1);
30197 wxPyEndAllowThreads(__tstate);
30198 if (PyErr_Occurred()) SWIG_fail;
30199 }
30200 resultobj = SWIG_From_int(static_cast< int >(result));
30201 return resultobj;
30202 fail:
30203 return NULL;
30204 }
30205
30206
30207 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30208 PyObject *resultobj = 0;
30209 int arg1 ;
30210 int result;
30211 int val1 ;
30212 int ecode1 = 0 ;
30213 PyObject * obj0 = 0 ;
30214 char * kwnames[] = {
30215 (char *) "winid", NULL
30216 };
30217
30218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30219 ecode1 = SWIG_AsVal_int(obj0, &val1);
30220 if (!SWIG_IsOK(ecode1)) {
30221 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30222 }
30223 arg1 = static_cast< int >(val1);
30224 {
30225 PyThreadState* __tstate = wxPyBeginAllowThreads();
30226 result = (int)wxWindow::PrevControlId(arg1);
30227 wxPyEndAllowThreads(__tstate);
30228 if (PyErr_Occurred()) SWIG_fail;
30229 }
30230 resultobj = SWIG_From_int(static_cast< int >(result));
30231 return resultobj;
30232 fail:
30233 return NULL;
30234 }
30235
30236
30237 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30238 PyObject *resultobj = 0;
30239 wxWindow *arg1 = (wxWindow *) 0 ;
30240 wxSize *arg2 = 0 ;
30241 void *argp1 = 0 ;
30242 int res1 = 0 ;
30243 wxSize temp2 ;
30244 PyObject * obj0 = 0 ;
30245 PyObject * obj1 = 0 ;
30246 char * kwnames[] = {
30247 (char *) "self",(char *) "size", NULL
30248 };
30249
30250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30252 if (!SWIG_IsOK(res1)) {
30253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30254 }
30255 arg1 = reinterpret_cast< wxWindow * >(argp1);
30256 {
30257 arg2 = &temp2;
30258 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30259 }
30260 {
30261 PyThreadState* __tstate = wxPyBeginAllowThreads();
30262 (arg1)->SetSize((wxSize const &)*arg2);
30263 wxPyEndAllowThreads(__tstate);
30264 if (PyErr_Occurred()) SWIG_fail;
30265 }
30266 resultobj = SWIG_Py_Void();
30267 return resultobj;
30268 fail:
30269 return NULL;
30270 }
30271
30272
30273 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30274 PyObject *resultobj = 0;
30275 wxWindow *arg1 = (wxWindow *) 0 ;
30276 int arg2 ;
30277 int arg3 ;
30278 int arg4 ;
30279 int arg5 ;
30280 int arg6 = (int) wxSIZE_AUTO ;
30281 void *argp1 = 0 ;
30282 int res1 = 0 ;
30283 int val2 ;
30284 int ecode2 = 0 ;
30285 int val3 ;
30286 int ecode3 = 0 ;
30287 int val4 ;
30288 int ecode4 = 0 ;
30289 int val5 ;
30290 int ecode5 = 0 ;
30291 int val6 ;
30292 int ecode6 = 0 ;
30293 PyObject * obj0 = 0 ;
30294 PyObject * obj1 = 0 ;
30295 PyObject * obj2 = 0 ;
30296 PyObject * obj3 = 0 ;
30297 PyObject * obj4 = 0 ;
30298 PyObject * obj5 = 0 ;
30299 char * kwnames[] = {
30300 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30301 };
30302
30303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30305 if (!SWIG_IsOK(res1)) {
30306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30307 }
30308 arg1 = reinterpret_cast< wxWindow * >(argp1);
30309 ecode2 = SWIG_AsVal_int(obj1, &val2);
30310 if (!SWIG_IsOK(ecode2)) {
30311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30312 }
30313 arg2 = static_cast< int >(val2);
30314 ecode3 = SWIG_AsVal_int(obj2, &val3);
30315 if (!SWIG_IsOK(ecode3)) {
30316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30317 }
30318 arg3 = static_cast< int >(val3);
30319 ecode4 = SWIG_AsVal_int(obj3, &val4);
30320 if (!SWIG_IsOK(ecode4)) {
30321 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30322 }
30323 arg4 = static_cast< int >(val4);
30324 ecode5 = SWIG_AsVal_int(obj4, &val5);
30325 if (!SWIG_IsOK(ecode5)) {
30326 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30327 }
30328 arg5 = static_cast< int >(val5);
30329 if (obj5) {
30330 ecode6 = SWIG_AsVal_int(obj5, &val6);
30331 if (!SWIG_IsOK(ecode6)) {
30332 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30333 }
30334 arg6 = static_cast< int >(val6);
30335 }
30336 {
30337 PyThreadState* __tstate = wxPyBeginAllowThreads();
30338 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30339 wxPyEndAllowThreads(__tstate);
30340 if (PyErr_Occurred()) SWIG_fail;
30341 }
30342 resultobj = SWIG_Py_Void();
30343 return resultobj;
30344 fail:
30345 return NULL;
30346 }
30347
30348
30349 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30350 PyObject *resultobj = 0;
30351 wxWindow *arg1 = (wxWindow *) 0 ;
30352 wxRect *arg2 = 0 ;
30353 int arg3 = (int) wxSIZE_AUTO ;
30354 void *argp1 = 0 ;
30355 int res1 = 0 ;
30356 wxRect temp2 ;
30357 int val3 ;
30358 int ecode3 = 0 ;
30359 PyObject * obj0 = 0 ;
30360 PyObject * obj1 = 0 ;
30361 PyObject * obj2 = 0 ;
30362 char * kwnames[] = {
30363 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30364 };
30365
30366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30368 if (!SWIG_IsOK(res1)) {
30369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30370 }
30371 arg1 = reinterpret_cast< wxWindow * >(argp1);
30372 {
30373 arg2 = &temp2;
30374 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30375 }
30376 if (obj2) {
30377 ecode3 = SWIG_AsVal_int(obj2, &val3);
30378 if (!SWIG_IsOK(ecode3)) {
30379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30380 }
30381 arg3 = static_cast< int >(val3);
30382 }
30383 {
30384 PyThreadState* __tstate = wxPyBeginAllowThreads();
30385 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30386 wxPyEndAllowThreads(__tstate);
30387 if (PyErr_Occurred()) SWIG_fail;
30388 }
30389 resultobj = SWIG_Py_Void();
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30397 PyObject *resultobj = 0;
30398 wxWindow *arg1 = (wxWindow *) 0 ;
30399 int arg2 ;
30400 int arg3 ;
30401 void *argp1 = 0 ;
30402 int res1 = 0 ;
30403 int val2 ;
30404 int ecode2 = 0 ;
30405 int val3 ;
30406 int ecode3 = 0 ;
30407 PyObject * obj0 = 0 ;
30408 PyObject * obj1 = 0 ;
30409 PyObject * obj2 = 0 ;
30410 char * kwnames[] = {
30411 (char *) "self",(char *) "width",(char *) "height", NULL
30412 };
30413
30414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30416 if (!SWIG_IsOK(res1)) {
30417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30418 }
30419 arg1 = reinterpret_cast< wxWindow * >(argp1);
30420 ecode2 = SWIG_AsVal_int(obj1, &val2);
30421 if (!SWIG_IsOK(ecode2)) {
30422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30423 }
30424 arg2 = static_cast< int >(val2);
30425 ecode3 = SWIG_AsVal_int(obj2, &val3);
30426 if (!SWIG_IsOK(ecode3)) {
30427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30428 }
30429 arg3 = static_cast< int >(val3);
30430 {
30431 PyThreadState* __tstate = wxPyBeginAllowThreads();
30432 (arg1)->SetSize(arg2,arg3);
30433 wxPyEndAllowThreads(__tstate);
30434 if (PyErr_Occurred()) SWIG_fail;
30435 }
30436 resultobj = SWIG_Py_Void();
30437 return resultobj;
30438 fail:
30439 return NULL;
30440 }
30441
30442
30443 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30444 PyObject *resultobj = 0;
30445 wxWindow *arg1 = (wxWindow *) 0 ;
30446 wxPoint *arg2 = 0 ;
30447 int arg3 = (int) wxSIZE_USE_EXISTING ;
30448 void *argp1 = 0 ;
30449 int res1 = 0 ;
30450 wxPoint temp2 ;
30451 int val3 ;
30452 int ecode3 = 0 ;
30453 PyObject * obj0 = 0 ;
30454 PyObject * obj1 = 0 ;
30455 PyObject * obj2 = 0 ;
30456 char * kwnames[] = {
30457 (char *) "self",(char *) "pt",(char *) "flags", NULL
30458 };
30459
30460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30462 if (!SWIG_IsOK(res1)) {
30463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30464 }
30465 arg1 = reinterpret_cast< wxWindow * >(argp1);
30466 {
30467 arg2 = &temp2;
30468 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30469 }
30470 if (obj2) {
30471 ecode3 = SWIG_AsVal_int(obj2, &val3);
30472 if (!SWIG_IsOK(ecode3)) {
30473 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30474 }
30475 arg3 = static_cast< int >(val3);
30476 }
30477 {
30478 PyThreadState* __tstate = wxPyBeginAllowThreads();
30479 (arg1)->Move((wxPoint const &)*arg2,arg3);
30480 wxPyEndAllowThreads(__tstate);
30481 if (PyErr_Occurred()) SWIG_fail;
30482 }
30483 resultobj = SWIG_Py_Void();
30484 return resultobj;
30485 fail:
30486 return NULL;
30487 }
30488
30489
30490 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30491 PyObject *resultobj = 0;
30492 wxWindow *arg1 = (wxWindow *) 0 ;
30493 int arg2 ;
30494 int arg3 ;
30495 int arg4 = (int) wxSIZE_USE_EXISTING ;
30496 void *argp1 = 0 ;
30497 int res1 = 0 ;
30498 int val2 ;
30499 int ecode2 = 0 ;
30500 int val3 ;
30501 int ecode3 = 0 ;
30502 int val4 ;
30503 int ecode4 = 0 ;
30504 PyObject * obj0 = 0 ;
30505 PyObject * obj1 = 0 ;
30506 PyObject * obj2 = 0 ;
30507 PyObject * obj3 = 0 ;
30508 char * kwnames[] = {
30509 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30510 };
30511
30512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30514 if (!SWIG_IsOK(res1)) {
30515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30516 }
30517 arg1 = reinterpret_cast< wxWindow * >(argp1);
30518 ecode2 = SWIG_AsVal_int(obj1, &val2);
30519 if (!SWIG_IsOK(ecode2)) {
30520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30521 }
30522 arg2 = static_cast< int >(val2);
30523 ecode3 = SWIG_AsVal_int(obj2, &val3);
30524 if (!SWIG_IsOK(ecode3)) {
30525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30526 }
30527 arg3 = static_cast< int >(val3);
30528 if (obj3) {
30529 ecode4 = SWIG_AsVal_int(obj3, &val4);
30530 if (!SWIG_IsOK(ecode4)) {
30531 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30532 }
30533 arg4 = static_cast< int >(val4);
30534 }
30535 {
30536 PyThreadState* __tstate = wxPyBeginAllowThreads();
30537 (arg1)->Move(arg2,arg3,arg4);
30538 wxPyEndAllowThreads(__tstate);
30539 if (PyErr_Occurred()) SWIG_fail;
30540 }
30541 resultobj = SWIG_Py_Void();
30542 return resultobj;
30543 fail:
30544 return NULL;
30545 }
30546
30547
30548 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30549 PyObject *resultobj = 0;
30550 wxWindow *arg1 = (wxWindow *) 0 ;
30551 wxSize const &arg2_defvalue = wxDefaultSize ;
30552 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30553 void *argp1 = 0 ;
30554 int res1 = 0 ;
30555 wxSize temp2 ;
30556 PyObject * obj0 = 0 ;
30557 PyObject * obj1 = 0 ;
30558 char * kwnames[] = {
30559 (char *) "self",(char *) "size", NULL
30560 };
30561
30562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30564 if (!SWIG_IsOK(res1)) {
30565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30566 }
30567 arg1 = reinterpret_cast< wxWindow * >(argp1);
30568 if (obj1) {
30569 {
30570 arg2 = &temp2;
30571 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30572 }
30573 }
30574 {
30575 PyThreadState* __tstate = wxPyBeginAllowThreads();
30576 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30577 wxPyEndAllowThreads(__tstate);
30578 if (PyErr_Occurred()) SWIG_fail;
30579 }
30580 resultobj = SWIG_Py_Void();
30581 return resultobj;
30582 fail:
30583 return NULL;
30584 }
30585
30586
30587 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30588 PyObject *resultobj = 0;
30589 wxWindow *arg1 = (wxWindow *) 0 ;
30590 void *argp1 = 0 ;
30591 int res1 = 0 ;
30592 PyObject *swig_obj[1] ;
30593
30594 if (!args) SWIG_fail;
30595 swig_obj[0] = args;
30596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30597 if (!SWIG_IsOK(res1)) {
30598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30599 }
30600 arg1 = reinterpret_cast< wxWindow * >(argp1);
30601 {
30602 PyThreadState* __tstate = wxPyBeginAllowThreads();
30603 (arg1)->Raise();
30604 wxPyEndAllowThreads(__tstate);
30605 if (PyErr_Occurred()) SWIG_fail;
30606 }
30607 resultobj = SWIG_Py_Void();
30608 return resultobj;
30609 fail:
30610 return NULL;
30611 }
30612
30613
30614 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30615 PyObject *resultobj = 0;
30616 wxWindow *arg1 = (wxWindow *) 0 ;
30617 void *argp1 = 0 ;
30618 int res1 = 0 ;
30619 PyObject *swig_obj[1] ;
30620
30621 if (!args) SWIG_fail;
30622 swig_obj[0] = args;
30623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30624 if (!SWIG_IsOK(res1)) {
30625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30626 }
30627 arg1 = reinterpret_cast< wxWindow * >(argp1);
30628 {
30629 PyThreadState* __tstate = wxPyBeginAllowThreads();
30630 (arg1)->Lower();
30631 wxPyEndAllowThreads(__tstate);
30632 if (PyErr_Occurred()) SWIG_fail;
30633 }
30634 resultobj = SWIG_Py_Void();
30635 return resultobj;
30636 fail:
30637 return NULL;
30638 }
30639
30640
30641 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30642 PyObject *resultobj = 0;
30643 wxWindow *arg1 = (wxWindow *) 0 ;
30644 wxSize *arg2 = 0 ;
30645 void *argp1 = 0 ;
30646 int res1 = 0 ;
30647 wxSize temp2 ;
30648 PyObject * obj0 = 0 ;
30649 PyObject * obj1 = 0 ;
30650 char * kwnames[] = {
30651 (char *) "self",(char *) "size", NULL
30652 };
30653
30654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30656 if (!SWIG_IsOK(res1)) {
30657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30658 }
30659 arg1 = reinterpret_cast< wxWindow * >(argp1);
30660 {
30661 arg2 = &temp2;
30662 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30663 }
30664 {
30665 PyThreadState* __tstate = wxPyBeginAllowThreads();
30666 (arg1)->SetClientSize((wxSize const &)*arg2);
30667 wxPyEndAllowThreads(__tstate);
30668 if (PyErr_Occurred()) SWIG_fail;
30669 }
30670 resultobj = SWIG_Py_Void();
30671 return resultobj;
30672 fail:
30673 return NULL;
30674 }
30675
30676
30677 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30678 PyObject *resultobj = 0;
30679 wxWindow *arg1 = (wxWindow *) 0 ;
30680 int arg2 ;
30681 int arg3 ;
30682 void *argp1 = 0 ;
30683 int res1 = 0 ;
30684 int val2 ;
30685 int ecode2 = 0 ;
30686 int val3 ;
30687 int ecode3 = 0 ;
30688 PyObject * obj0 = 0 ;
30689 PyObject * obj1 = 0 ;
30690 PyObject * obj2 = 0 ;
30691 char * kwnames[] = {
30692 (char *) "self",(char *) "width",(char *) "height", NULL
30693 };
30694
30695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30697 if (!SWIG_IsOK(res1)) {
30698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30699 }
30700 arg1 = reinterpret_cast< wxWindow * >(argp1);
30701 ecode2 = SWIG_AsVal_int(obj1, &val2);
30702 if (!SWIG_IsOK(ecode2)) {
30703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30704 }
30705 arg2 = static_cast< int >(val2);
30706 ecode3 = SWIG_AsVal_int(obj2, &val3);
30707 if (!SWIG_IsOK(ecode3)) {
30708 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30709 }
30710 arg3 = static_cast< int >(val3);
30711 {
30712 PyThreadState* __tstate = wxPyBeginAllowThreads();
30713 (arg1)->SetClientSize(arg2,arg3);
30714 wxPyEndAllowThreads(__tstate);
30715 if (PyErr_Occurred()) SWIG_fail;
30716 }
30717 resultobj = SWIG_Py_Void();
30718 return resultobj;
30719 fail:
30720 return NULL;
30721 }
30722
30723
30724 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30725 PyObject *resultobj = 0;
30726 wxWindow *arg1 = (wxWindow *) 0 ;
30727 wxRect *arg2 = 0 ;
30728 void *argp1 = 0 ;
30729 int res1 = 0 ;
30730 wxRect temp2 ;
30731 PyObject * obj0 = 0 ;
30732 PyObject * obj1 = 0 ;
30733 char * kwnames[] = {
30734 (char *) "self",(char *) "rect", NULL
30735 };
30736
30737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30739 if (!SWIG_IsOK(res1)) {
30740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30741 }
30742 arg1 = reinterpret_cast< wxWindow * >(argp1);
30743 {
30744 arg2 = &temp2;
30745 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30746 }
30747 {
30748 PyThreadState* __tstate = wxPyBeginAllowThreads();
30749 (arg1)->SetClientSize((wxRect const &)*arg2);
30750 wxPyEndAllowThreads(__tstate);
30751 if (PyErr_Occurred()) SWIG_fail;
30752 }
30753 resultobj = SWIG_Py_Void();
30754 return resultobj;
30755 fail:
30756 return NULL;
30757 }
30758
30759
30760 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30761 PyObject *resultobj = 0;
30762 wxWindow *arg1 = (wxWindow *) 0 ;
30763 wxPoint result;
30764 void *argp1 = 0 ;
30765 int res1 = 0 ;
30766 PyObject *swig_obj[1] ;
30767
30768 if (!args) SWIG_fail;
30769 swig_obj[0] = args;
30770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30771 if (!SWIG_IsOK(res1)) {
30772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30773 }
30774 arg1 = reinterpret_cast< wxWindow * >(argp1);
30775 {
30776 PyThreadState* __tstate = wxPyBeginAllowThreads();
30777 result = ((wxWindow const *)arg1)->GetPosition();
30778 wxPyEndAllowThreads(__tstate);
30779 if (PyErr_Occurred()) SWIG_fail;
30780 }
30781 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30782 return resultobj;
30783 fail:
30784 return NULL;
30785 }
30786
30787
30788 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30789 PyObject *resultobj = 0;
30790 wxWindow *arg1 = (wxWindow *) 0 ;
30791 int *arg2 = (int *) 0 ;
30792 int *arg3 = (int *) 0 ;
30793 void *argp1 = 0 ;
30794 int res1 = 0 ;
30795 int temp2 ;
30796 int res2 = SWIG_TMPOBJ ;
30797 int temp3 ;
30798 int res3 = SWIG_TMPOBJ ;
30799 PyObject *swig_obj[1] ;
30800
30801 arg2 = &temp2;
30802 arg3 = &temp3;
30803 if (!args) SWIG_fail;
30804 swig_obj[0] = args;
30805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30806 if (!SWIG_IsOK(res1)) {
30807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30808 }
30809 arg1 = reinterpret_cast< wxWindow * >(argp1);
30810 {
30811 PyThreadState* __tstate = wxPyBeginAllowThreads();
30812 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30813 wxPyEndAllowThreads(__tstate);
30814 if (PyErr_Occurred()) SWIG_fail;
30815 }
30816 resultobj = SWIG_Py_Void();
30817 if (SWIG_IsTmpObj(res2)) {
30818 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30819 } else {
30820 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30822 }
30823 if (SWIG_IsTmpObj(res3)) {
30824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30825 } else {
30826 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30828 }
30829 return resultobj;
30830 fail:
30831 return NULL;
30832 }
30833
30834
30835 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30836 PyObject *resultobj = 0;
30837 wxWindow *arg1 = (wxWindow *) 0 ;
30838 wxPoint result;
30839 void *argp1 = 0 ;
30840 int res1 = 0 ;
30841 PyObject *swig_obj[1] ;
30842
30843 if (!args) SWIG_fail;
30844 swig_obj[0] = args;
30845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30846 if (!SWIG_IsOK(res1)) {
30847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30848 }
30849 arg1 = reinterpret_cast< wxWindow * >(argp1);
30850 {
30851 PyThreadState* __tstate = wxPyBeginAllowThreads();
30852 result = ((wxWindow const *)arg1)->GetScreenPosition();
30853 wxPyEndAllowThreads(__tstate);
30854 if (PyErr_Occurred()) SWIG_fail;
30855 }
30856 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30857 return resultobj;
30858 fail:
30859 return NULL;
30860 }
30861
30862
30863 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30864 PyObject *resultobj = 0;
30865 wxWindow *arg1 = (wxWindow *) 0 ;
30866 int *arg2 = (int *) 0 ;
30867 int *arg3 = (int *) 0 ;
30868 void *argp1 = 0 ;
30869 int res1 = 0 ;
30870 int temp2 ;
30871 int res2 = SWIG_TMPOBJ ;
30872 int temp3 ;
30873 int res3 = SWIG_TMPOBJ ;
30874 PyObject *swig_obj[1] ;
30875
30876 arg2 = &temp2;
30877 arg3 = &temp3;
30878 if (!args) SWIG_fail;
30879 swig_obj[0] = args;
30880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30881 if (!SWIG_IsOK(res1)) {
30882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30883 }
30884 arg1 = reinterpret_cast< wxWindow * >(argp1);
30885 {
30886 PyThreadState* __tstate = wxPyBeginAllowThreads();
30887 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30888 wxPyEndAllowThreads(__tstate);
30889 if (PyErr_Occurred()) SWIG_fail;
30890 }
30891 resultobj = SWIG_Py_Void();
30892 if (SWIG_IsTmpObj(res2)) {
30893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30894 } else {
30895 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30896 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30897 }
30898 if (SWIG_IsTmpObj(res3)) {
30899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30900 } else {
30901 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30903 }
30904 return resultobj;
30905 fail:
30906 return NULL;
30907 }
30908
30909
30910 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30911 PyObject *resultobj = 0;
30912 wxWindow *arg1 = (wxWindow *) 0 ;
30913 wxRect result;
30914 void *argp1 = 0 ;
30915 int res1 = 0 ;
30916 PyObject *swig_obj[1] ;
30917
30918 if (!args) SWIG_fail;
30919 swig_obj[0] = args;
30920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30921 if (!SWIG_IsOK(res1)) {
30922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30923 }
30924 arg1 = reinterpret_cast< wxWindow * >(argp1);
30925 {
30926 PyThreadState* __tstate = wxPyBeginAllowThreads();
30927 result = ((wxWindow const *)arg1)->GetScreenRect();
30928 wxPyEndAllowThreads(__tstate);
30929 if (PyErr_Occurred()) SWIG_fail;
30930 }
30931 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30932 return resultobj;
30933 fail:
30934 return NULL;
30935 }
30936
30937
30938 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30939 PyObject *resultobj = 0;
30940 wxWindow *arg1 = (wxWindow *) 0 ;
30941 wxSize result;
30942 void *argp1 = 0 ;
30943 int res1 = 0 ;
30944 PyObject *swig_obj[1] ;
30945
30946 if (!args) SWIG_fail;
30947 swig_obj[0] = args;
30948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30949 if (!SWIG_IsOK(res1)) {
30950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30951 }
30952 arg1 = reinterpret_cast< wxWindow * >(argp1);
30953 {
30954 PyThreadState* __tstate = wxPyBeginAllowThreads();
30955 result = ((wxWindow const *)arg1)->GetSize();
30956 wxPyEndAllowThreads(__tstate);
30957 if (PyErr_Occurred()) SWIG_fail;
30958 }
30959 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30960 return resultobj;
30961 fail:
30962 return NULL;
30963 }
30964
30965
30966 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30967 PyObject *resultobj = 0;
30968 wxWindow *arg1 = (wxWindow *) 0 ;
30969 int *arg2 = (int *) 0 ;
30970 int *arg3 = (int *) 0 ;
30971 void *argp1 = 0 ;
30972 int res1 = 0 ;
30973 int temp2 ;
30974 int res2 = SWIG_TMPOBJ ;
30975 int temp3 ;
30976 int res3 = SWIG_TMPOBJ ;
30977 PyObject *swig_obj[1] ;
30978
30979 arg2 = &temp2;
30980 arg3 = &temp3;
30981 if (!args) SWIG_fail;
30982 swig_obj[0] = args;
30983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30984 if (!SWIG_IsOK(res1)) {
30985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30986 }
30987 arg1 = reinterpret_cast< wxWindow * >(argp1);
30988 {
30989 PyThreadState* __tstate = wxPyBeginAllowThreads();
30990 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30991 wxPyEndAllowThreads(__tstate);
30992 if (PyErr_Occurred()) SWIG_fail;
30993 }
30994 resultobj = SWIG_Py_Void();
30995 if (SWIG_IsTmpObj(res2)) {
30996 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30997 } else {
30998 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31000 }
31001 if (SWIG_IsTmpObj(res3)) {
31002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31003 } else {
31004 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31006 }
31007 return resultobj;
31008 fail:
31009 return NULL;
31010 }
31011
31012
31013 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31014 PyObject *resultobj = 0;
31015 wxWindow *arg1 = (wxWindow *) 0 ;
31016 wxRect result;
31017 void *argp1 = 0 ;
31018 int res1 = 0 ;
31019 PyObject *swig_obj[1] ;
31020
31021 if (!args) SWIG_fail;
31022 swig_obj[0] = args;
31023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31024 if (!SWIG_IsOK(res1)) {
31025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31026 }
31027 arg1 = reinterpret_cast< wxWindow * >(argp1);
31028 {
31029 PyThreadState* __tstate = wxPyBeginAllowThreads();
31030 result = ((wxWindow const *)arg1)->GetRect();
31031 wxPyEndAllowThreads(__tstate);
31032 if (PyErr_Occurred()) SWIG_fail;
31033 }
31034 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31035 return resultobj;
31036 fail:
31037 return NULL;
31038 }
31039
31040
31041 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31042 PyObject *resultobj = 0;
31043 wxWindow *arg1 = (wxWindow *) 0 ;
31044 wxSize result;
31045 void *argp1 = 0 ;
31046 int res1 = 0 ;
31047 PyObject *swig_obj[1] ;
31048
31049 if (!args) SWIG_fail;
31050 swig_obj[0] = args;
31051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31052 if (!SWIG_IsOK(res1)) {
31053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31054 }
31055 arg1 = reinterpret_cast< wxWindow * >(argp1);
31056 {
31057 PyThreadState* __tstate = wxPyBeginAllowThreads();
31058 result = ((wxWindow const *)arg1)->GetClientSize();
31059 wxPyEndAllowThreads(__tstate);
31060 if (PyErr_Occurred()) SWIG_fail;
31061 }
31062 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31063 return resultobj;
31064 fail:
31065 return NULL;
31066 }
31067
31068
31069 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31070 PyObject *resultobj = 0;
31071 wxWindow *arg1 = (wxWindow *) 0 ;
31072 int *arg2 = (int *) 0 ;
31073 int *arg3 = (int *) 0 ;
31074 void *argp1 = 0 ;
31075 int res1 = 0 ;
31076 int temp2 ;
31077 int res2 = SWIG_TMPOBJ ;
31078 int temp3 ;
31079 int res3 = SWIG_TMPOBJ ;
31080 PyObject *swig_obj[1] ;
31081
31082 arg2 = &temp2;
31083 arg3 = &temp3;
31084 if (!args) SWIG_fail;
31085 swig_obj[0] = args;
31086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31087 if (!SWIG_IsOK(res1)) {
31088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31089 }
31090 arg1 = reinterpret_cast< wxWindow * >(argp1);
31091 {
31092 PyThreadState* __tstate = wxPyBeginAllowThreads();
31093 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31094 wxPyEndAllowThreads(__tstate);
31095 if (PyErr_Occurred()) SWIG_fail;
31096 }
31097 resultobj = SWIG_Py_Void();
31098 if (SWIG_IsTmpObj(res2)) {
31099 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31100 } else {
31101 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31102 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31103 }
31104 if (SWIG_IsTmpObj(res3)) {
31105 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31106 } else {
31107 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31108 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31109 }
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31117 PyObject *resultobj = 0;
31118 wxWindow *arg1 = (wxWindow *) 0 ;
31119 wxPoint result;
31120 void *argp1 = 0 ;
31121 int res1 = 0 ;
31122 PyObject *swig_obj[1] ;
31123
31124 if (!args) SWIG_fail;
31125 swig_obj[0] = args;
31126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31127 if (!SWIG_IsOK(res1)) {
31128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31129 }
31130 arg1 = reinterpret_cast< wxWindow * >(argp1);
31131 {
31132 PyThreadState* __tstate = wxPyBeginAllowThreads();
31133 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31134 wxPyEndAllowThreads(__tstate);
31135 if (PyErr_Occurred()) SWIG_fail;
31136 }
31137 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31138 return resultobj;
31139 fail:
31140 return NULL;
31141 }
31142
31143
31144 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31145 PyObject *resultobj = 0;
31146 wxWindow *arg1 = (wxWindow *) 0 ;
31147 wxRect result;
31148 void *argp1 = 0 ;
31149 int res1 = 0 ;
31150 PyObject *swig_obj[1] ;
31151
31152 if (!args) SWIG_fail;
31153 swig_obj[0] = args;
31154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31155 if (!SWIG_IsOK(res1)) {
31156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31157 }
31158 arg1 = reinterpret_cast< wxWindow * >(argp1);
31159 {
31160 PyThreadState* __tstate = wxPyBeginAllowThreads();
31161 result = ((wxWindow const *)arg1)->GetClientRect();
31162 wxPyEndAllowThreads(__tstate);
31163 if (PyErr_Occurred()) SWIG_fail;
31164 }
31165 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31166 return resultobj;
31167 fail:
31168 return NULL;
31169 }
31170
31171
31172 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31173 PyObject *resultobj = 0;
31174 wxWindow *arg1 = (wxWindow *) 0 ;
31175 wxSize result;
31176 void *argp1 = 0 ;
31177 int res1 = 0 ;
31178 PyObject *swig_obj[1] ;
31179
31180 if (!args) SWIG_fail;
31181 swig_obj[0] = args;
31182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31183 if (!SWIG_IsOK(res1)) {
31184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31185 }
31186 arg1 = reinterpret_cast< wxWindow * >(argp1);
31187 {
31188 PyThreadState* __tstate = wxPyBeginAllowThreads();
31189 result = ((wxWindow const *)arg1)->GetBestSize();
31190 wxPyEndAllowThreads(__tstate);
31191 if (PyErr_Occurred()) SWIG_fail;
31192 }
31193 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31194 return resultobj;
31195 fail:
31196 return NULL;
31197 }
31198
31199
31200 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31201 PyObject *resultobj = 0;
31202 wxWindow *arg1 = (wxWindow *) 0 ;
31203 int *arg2 = (int *) 0 ;
31204 int *arg3 = (int *) 0 ;
31205 void *argp1 = 0 ;
31206 int res1 = 0 ;
31207 int temp2 ;
31208 int res2 = SWIG_TMPOBJ ;
31209 int temp3 ;
31210 int res3 = SWIG_TMPOBJ ;
31211 PyObject *swig_obj[1] ;
31212
31213 arg2 = &temp2;
31214 arg3 = &temp3;
31215 if (!args) SWIG_fail;
31216 swig_obj[0] = args;
31217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31218 if (!SWIG_IsOK(res1)) {
31219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31220 }
31221 arg1 = reinterpret_cast< wxWindow * >(argp1);
31222 {
31223 PyThreadState* __tstate = wxPyBeginAllowThreads();
31224 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31225 wxPyEndAllowThreads(__tstate);
31226 if (PyErr_Occurred()) SWIG_fail;
31227 }
31228 resultobj = SWIG_Py_Void();
31229 if (SWIG_IsTmpObj(res2)) {
31230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31231 } else {
31232 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31234 }
31235 if (SWIG_IsTmpObj(res3)) {
31236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31237 } else {
31238 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31240 }
31241 return resultobj;
31242 fail:
31243 return NULL;
31244 }
31245
31246
31247 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31248 PyObject *resultobj = 0;
31249 wxWindow *arg1 = (wxWindow *) 0 ;
31250 void *argp1 = 0 ;
31251 int res1 = 0 ;
31252 PyObject *swig_obj[1] ;
31253
31254 if (!args) SWIG_fail;
31255 swig_obj[0] = args;
31256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31257 if (!SWIG_IsOK(res1)) {
31258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31259 }
31260 arg1 = reinterpret_cast< wxWindow * >(argp1);
31261 {
31262 PyThreadState* __tstate = wxPyBeginAllowThreads();
31263 (arg1)->InvalidateBestSize();
31264 wxPyEndAllowThreads(__tstate);
31265 if (PyErr_Occurred()) SWIG_fail;
31266 }
31267 resultobj = SWIG_Py_Void();
31268 return resultobj;
31269 fail:
31270 return NULL;
31271 }
31272
31273
31274 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31275 PyObject *resultobj = 0;
31276 wxWindow *arg1 = (wxWindow *) 0 ;
31277 wxSize *arg2 = 0 ;
31278 void *argp1 = 0 ;
31279 int res1 = 0 ;
31280 wxSize temp2 ;
31281 PyObject * obj0 = 0 ;
31282 PyObject * obj1 = 0 ;
31283 char * kwnames[] = {
31284 (char *) "self",(char *) "size", NULL
31285 };
31286
31287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31289 if (!SWIG_IsOK(res1)) {
31290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31291 }
31292 arg1 = reinterpret_cast< wxWindow * >(argp1);
31293 {
31294 arg2 = &temp2;
31295 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31296 }
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31300 wxPyEndAllowThreads(__tstate);
31301 if (PyErr_Occurred()) SWIG_fail;
31302 }
31303 resultobj = SWIG_Py_Void();
31304 return resultobj;
31305 fail:
31306 return NULL;
31307 }
31308
31309
31310 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31311 PyObject *resultobj = 0;
31312 wxWindow *arg1 = (wxWindow *) 0 ;
31313 wxSize result;
31314 void *argp1 = 0 ;
31315 int res1 = 0 ;
31316 PyObject *swig_obj[1] ;
31317
31318 if (!args) SWIG_fail;
31319 swig_obj[0] = args;
31320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31321 if (!SWIG_IsOK(res1)) {
31322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31323 }
31324 arg1 = reinterpret_cast< wxWindow * >(argp1);
31325 {
31326 PyThreadState* __tstate = wxPyBeginAllowThreads();
31327 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31328 wxPyEndAllowThreads(__tstate);
31329 if (PyErr_Occurred()) SWIG_fail;
31330 }
31331 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31332 return resultobj;
31333 fail:
31334 return NULL;
31335 }
31336
31337
31338 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31339 PyObject *resultobj = 0;
31340 wxWindow *arg1 = (wxWindow *) 0 ;
31341 wxSize result;
31342 void *argp1 = 0 ;
31343 int res1 = 0 ;
31344 PyObject *swig_obj[1] ;
31345
31346 if (!args) SWIG_fail;
31347 swig_obj[0] = args;
31348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31349 if (!SWIG_IsOK(res1)) {
31350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31351 }
31352 arg1 = reinterpret_cast< wxWindow * >(argp1);
31353 {
31354 PyThreadState* __tstate = wxPyBeginAllowThreads();
31355 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31356 wxPyEndAllowThreads(__tstate);
31357 if (PyErr_Occurred()) SWIG_fail;
31358 }
31359 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31360 return resultobj;
31361 fail:
31362 return NULL;
31363 }
31364
31365
31366 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31367 PyObject *resultobj = 0;
31368 wxWindow *arg1 = (wxWindow *) 0 ;
31369 int arg2 = (int) wxBOTH ;
31370 void *argp1 = 0 ;
31371 int res1 = 0 ;
31372 int val2 ;
31373 int ecode2 = 0 ;
31374 PyObject * obj0 = 0 ;
31375 PyObject * obj1 = 0 ;
31376 char * kwnames[] = {
31377 (char *) "self",(char *) "direction", NULL
31378 };
31379
31380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31382 if (!SWIG_IsOK(res1)) {
31383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31384 }
31385 arg1 = reinterpret_cast< wxWindow * >(argp1);
31386 if (obj1) {
31387 ecode2 = SWIG_AsVal_int(obj1, &val2);
31388 if (!SWIG_IsOK(ecode2)) {
31389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31390 }
31391 arg2 = static_cast< int >(val2);
31392 }
31393 {
31394 PyThreadState* __tstate = wxPyBeginAllowThreads();
31395 (arg1)->Center(arg2);
31396 wxPyEndAllowThreads(__tstate);
31397 if (PyErr_Occurred()) SWIG_fail;
31398 }
31399 resultobj = SWIG_Py_Void();
31400 return resultobj;
31401 fail:
31402 return NULL;
31403 }
31404
31405
31406 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31407 PyObject *resultobj = 0;
31408 wxWindow *arg1 = (wxWindow *) 0 ;
31409 int arg2 = (int) wxBOTH ;
31410 void *argp1 = 0 ;
31411 int res1 = 0 ;
31412 int val2 ;
31413 int ecode2 = 0 ;
31414 PyObject * obj0 = 0 ;
31415 PyObject * obj1 = 0 ;
31416 char * kwnames[] = {
31417 (char *) "self",(char *) "dir", NULL
31418 };
31419
31420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31422 if (!SWIG_IsOK(res1)) {
31423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31424 }
31425 arg1 = reinterpret_cast< wxWindow * >(argp1);
31426 if (obj1) {
31427 ecode2 = SWIG_AsVal_int(obj1, &val2);
31428 if (!SWIG_IsOK(ecode2)) {
31429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31430 }
31431 arg2 = static_cast< int >(val2);
31432 }
31433 {
31434 PyThreadState* __tstate = wxPyBeginAllowThreads();
31435 (arg1)->CenterOnParent(arg2);
31436 wxPyEndAllowThreads(__tstate);
31437 if (PyErr_Occurred()) SWIG_fail;
31438 }
31439 resultobj = SWIG_Py_Void();
31440 return resultobj;
31441 fail:
31442 return NULL;
31443 }
31444
31445
31446 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31447 PyObject *resultobj = 0;
31448 wxWindow *arg1 = (wxWindow *) 0 ;
31449 void *argp1 = 0 ;
31450 int res1 = 0 ;
31451 PyObject *swig_obj[1] ;
31452
31453 if (!args) SWIG_fail;
31454 swig_obj[0] = args;
31455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31456 if (!SWIG_IsOK(res1)) {
31457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31458 }
31459 arg1 = reinterpret_cast< wxWindow * >(argp1);
31460 {
31461 PyThreadState* __tstate = wxPyBeginAllowThreads();
31462 (arg1)->Fit();
31463 wxPyEndAllowThreads(__tstate);
31464 if (PyErr_Occurred()) SWIG_fail;
31465 }
31466 resultobj = SWIG_Py_Void();
31467 return resultobj;
31468 fail:
31469 return NULL;
31470 }
31471
31472
31473 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31474 PyObject *resultobj = 0;
31475 wxWindow *arg1 = (wxWindow *) 0 ;
31476 void *argp1 = 0 ;
31477 int res1 = 0 ;
31478 PyObject *swig_obj[1] ;
31479
31480 if (!args) SWIG_fail;
31481 swig_obj[0] = args;
31482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31483 if (!SWIG_IsOK(res1)) {
31484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31485 }
31486 arg1 = reinterpret_cast< wxWindow * >(argp1);
31487 {
31488 PyThreadState* __tstate = wxPyBeginAllowThreads();
31489 (arg1)->FitInside();
31490 wxPyEndAllowThreads(__tstate);
31491 if (PyErr_Occurred()) SWIG_fail;
31492 }
31493 resultobj = SWIG_Py_Void();
31494 return resultobj;
31495 fail:
31496 return NULL;
31497 }
31498
31499
31500 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31501 PyObject *resultobj = 0;
31502 wxWindow *arg1 = (wxWindow *) 0 ;
31503 int arg2 ;
31504 int arg3 ;
31505 int arg4 = (int) -1 ;
31506 int arg5 = (int) -1 ;
31507 int arg6 = (int) -1 ;
31508 int arg7 = (int) -1 ;
31509 void *argp1 = 0 ;
31510 int res1 = 0 ;
31511 int val2 ;
31512 int ecode2 = 0 ;
31513 int val3 ;
31514 int ecode3 = 0 ;
31515 int val4 ;
31516 int ecode4 = 0 ;
31517 int val5 ;
31518 int ecode5 = 0 ;
31519 int val6 ;
31520 int ecode6 = 0 ;
31521 int val7 ;
31522 int ecode7 = 0 ;
31523 PyObject * obj0 = 0 ;
31524 PyObject * obj1 = 0 ;
31525 PyObject * obj2 = 0 ;
31526 PyObject * obj3 = 0 ;
31527 PyObject * obj4 = 0 ;
31528 PyObject * obj5 = 0 ;
31529 PyObject * obj6 = 0 ;
31530 char * kwnames[] = {
31531 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31532 };
31533
31534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31536 if (!SWIG_IsOK(res1)) {
31537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31538 }
31539 arg1 = reinterpret_cast< wxWindow * >(argp1);
31540 ecode2 = SWIG_AsVal_int(obj1, &val2);
31541 if (!SWIG_IsOK(ecode2)) {
31542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31543 }
31544 arg2 = static_cast< int >(val2);
31545 ecode3 = SWIG_AsVal_int(obj2, &val3);
31546 if (!SWIG_IsOK(ecode3)) {
31547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31548 }
31549 arg3 = static_cast< int >(val3);
31550 if (obj3) {
31551 ecode4 = SWIG_AsVal_int(obj3, &val4);
31552 if (!SWIG_IsOK(ecode4)) {
31553 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31554 }
31555 arg4 = static_cast< int >(val4);
31556 }
31557 if (obj4) {
31558 ecode5 = SWIG_AsVal_int(obj4, &val5);
31559 if (!SWIG_IsOK(ecode5)) {
31560 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31561 }
31562 arg5 = static_cast< int >(val5);
31563 }
31564 if (obj5) {
31565 ecode6 = SWIG_AsVal_int(obj5, &val6);
31566 if (!SWIG_IsOK(ecode6)) {
31567 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31568 }
31569 arg6 = static_cast< int >(val6);
31570 }
31571 if (obj6) {
31572 ecode7 = SWIG_AsVal_int(obj6, &val7);
31573 if (!SWIG_IsOK(ecode7)) {
31574 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31575 }
31576 arg7 = static_cast< int >(val7);
31577 }
31578 {
31579 PyThreadState* __tstate = wxPyBeginAllowThreads();
31580 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31581 wxPyEndAllowThreads(__tstate);
31582 if (PyErr_Occurred()) SWIG_fail;
31583 }
31584 resultobj = SWIG_Py_Void();
31585 return resultobj;
31586 fail:
31587 return NULL;
31588 }
31589
31590
31591 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31592 PyObject *resultobj = 0;
31593 wxWindow *arg1 = (wxWindow *) 0 ;
31594 wxSize *arg2 = 0 ;
31595 wxSize const &arg3_defvalue = wxDefaultSize ;
31596 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31597 wxSize const &arg4_defvalue = wxDefaultSize ;
31598 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31599 void *argp1 = 0 ;
31600 int res1 = 0 ;
31601 wxSize temp2 ;
31602 wxSize temp3 ;
31603 wxSize temp4 ;
31604 PyObject * obj0 = 0 ;
31605 PyObject * obj1 = 0 ;
31606 PyObject * obj2 = 0 ;
31607 PyObject * obj3 = 0 ;
31608 char * kwnames[] = {
31609 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31610 };
31611
31612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31614 if (!SWIG_IsOK(res1)) {
31615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31616 }
31617 arg1 = reinterpret_cast< wxWindow * >(argp1);
31618 {
31619 arg2 = &temp2;
31620 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31621 }
31622 if (obj2) {
31623 {
31624 arg3 = &temp3;
31625 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31626 }
31627 }
31628 if (obj3) {
31629 {
31630 arg4 = &temp4;
31631 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31632 }
31633 }
31634 {
31635 PyThreadState* __tstate = wxPyBeginAllowThreads();
31636 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31637 wxPyEndAllowThreads(__tstate);
31638 if (PyErr_Occurred()) SWIG_fail;
31639 }
31640 resultobj = SWIG_Py_Void();
31641 return resultobj;
31642 fail:
31643 return NULL;
31644 }
31645
31646
31647 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31648 PyObject *resultobj = 0;
31649 wxWindow *arg1 = (wxWindow *) 0 ;
31650 int arg2 ;
31651 int arg3 ;
31652 int arg4 = (int) -1 ;
31653 int arg5 = (int) -1 ;
31654 void *argp1 = 0 ;
31655 int res1 = 0 ;
31656 int val2 ;
31657 int ecode2 = 0 ;
31658 int val3 ;
31659 int ecode3 = 0 ;
31660 int val4 ;
31661 int ecode4 = 0 ;
31662 int val5 ;
31663 int ecode5 = 0 ;
31664 PyObject * obj0 = 0 ;
31665 PyObject * obj1 = 0 ;
31666 PyObject * obj2 = 0 ;
31667 PyObject * obj3 = 0 ;
31668 PyObject * obj4 = 0 ;
31669 char * kwnames[] = {
31670 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31671 };
31672
31673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31675 if (!SWIG_IsOK(res1)) {
31676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31677 }
31678 arg1 = reinterpret_cast< wxWindow * >(argp1);
31679 ecode2 = SWIG_AsVal_int(obj1, &val2);
31680 if (!SWIG_IsOK(ecode2)) {
31681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31682 }
31683 arg2 = static_cast< int >(val2);
31684 ecode3 = SWIG_AsVal_int(obj2, &val3);
31685 if (!SWIG_IsOK(ecode3)) {
31686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31687 }
31688 arg3 = static_cast< int >(val3);
31689 if (obj3) {
31690 ecode4 = SWIG_AsVal_int(obj3, &val4);
31691 if (!SWIG_IsOK(ecode4)) {
31692 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31693 }
31694 arg4 = static_cast< int >(val4);
31695 }
31696 if (obj4) {
31697 ecode5 = SWIG_AsVal_int(obj4, &val5);
31698 if (!SWIG_IsOK(ecode5)) {
31699 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31700 }
31701 arg5 = static_cast< int >(val5);
31702 }
31703 {
31704 PyThreadState* __tstate = wxPyBeginAllowThreads();
31705 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31706 wxPyEndAllowThreads(__tstate);
31707 if (PyErr_Occurred()) SWIG_fail;
31708 }
31709 resultobj = SWIG_Py_Void();
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31717 PyObject *resultobj = 0;
31718 wxWindow *arg1 = (wxWindow *) 0 ;
31719 wxSize *arg2 = 0 ;
31720 wxSize const &arg3_defvalue = wxDefaultSize ;
31721 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31722 void *argp1 = 0 ;
31723 int res1 = 0 ;
31724 wxSize temp2 ;
31725 wxSize temp3 ;
31726 PyObject * obj0 = 0 ;
31727 PyObject * obj1 = 0 ;
31728 PyObject * obj2 = 0 ;
31729 char * kwnames[] = {
31730 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31731 };
31732
31733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31735 if (!SWIG_IsOK(res1)) {
31736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31737 }
31738 arg1 = reinterpret_cast< wxWindow * >(argp1);
31739 {
31740 arg2 = &temp2;
31741 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31742 }
31743 if (obj2) {
31744 {
31745 arg3 = &temp3;
31746 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31747 }
31748 }
31749 {
31750 PyThreadState* __tstate = wxPyBeginAllowThreads();
31751 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31752 wxPyEndAllowThreads(__tstate);
31753 if (PyErr_Occurred()) SWIG_fail;
31754 }
31755 resultobj = SWIG_Py_Void();
31756 return resultobj;
31757 fail:
31758 return NULL;
31759 }
31760
31761
31762 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31763 PyObject *resultobj = 0;
31764 wxWindow *arg1 = (wxWindow *) 0 ;
31765 wxSize result;
31766 void *argp1 = 0 ;
31767 int res1 = 0 ;
31768 PyObject *swig_obj[1] ;
31769
31770 if (!args) SWIG_fail;
31771 swig_obj[0] = args;
31772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31773 if (!SWIG_IsOK(res1)) {
31774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31775 }
31776 arg1 = reinterpret_cast< wxWindow * >(argp1);
31777 {
31778 PyThreadState* __tstate = wxPyBeginAllowThreads();
31779 result = ((wxWindow const *)arg1)->GetMaxSize();
31780 wxPyEndAllowThreads(__tstate);
31781 if (PyErr_Occurred()) SWIG_fail;
31782 }
31783 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31784 return resultobj;
31785 fail:
31786 return NULL;
31787 }
31788
31789
31790 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31791 PyObject *resultobj = 0;
31792 wxWindow *arg1 = (wxWindow *) 0 ;
31793 wxSize result;
31794 void *argp1 = 0 ;
31795 int res1 = 0 ;
31796 PyObject *swig_obj[1] ;
31797
31798 if (!args) SWIG_fail;
31799 swig_obj[0] = args;
31800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31801 if (!SWIG_IsOK(res1)) {
31802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31803 }
31804 arg1 = reinterpret_cast< wxWindow * >(argp1);
31805 {
31806 PyThreadState* __tstate = wxPyBeginAllowThreads();
31807 result = ((wxWindow const *)arg1)->GetMinSize();
31808 wxPyEndAllowThreads(__tstate);
31809 if (PyErr_Occurred()) SWIG_fail;
31810 }
31811 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31812 return resultobj;
31813 fail:
31814 return NULL;
31815 }
31816
31817
31818 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31819 PyObject *resultobj = 0;
31820 wxWindow *arg1 = (wxWindow *) 0 ;
31821 wxSize *arg2 = 0 ;
31822 void *argp1 = 0 ;
31823 int res1 = 0 ;
31824 wxSize temp2 ;
31825 PyObject * obj0 = 0 ;
31826 PyObject * obj1 = 0 ;
31827 char * kwnames[] = {
31828 (char *) "self",(char *) "minSize", NULL
31829 };
31830
31831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31833 if (!SWIG_IsOK(res1)) {
31834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31835 }
31836 arg1 = reinterpret_cast< wxWindow * >(argp1);
31837 {
31838 arg2 = &temp2;
31839 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31840 }
31841 {
31842 PyThreadState* __tstate = wxPyBeginAllowThreads();
31843 (arg1)->SetMinSize((wxSize const &)*arg2);
31844 wxPyEndAllowThreads(__tstate);
31845 if (PyErr_Occurred()) SWIG_fail;
31846 }
31847 resultobj = SWIG_Py_Void();
31848 return resultobj;
31849 fail:
31850 return NULL;
31851 }
31852
31853
31854 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31855 PyObject *resultobj = 0;
31856 wxWindow *arg1 = (wxWindow *) 0 ;
31857 wxSize *arg2 = 0 ;
31858 void *argp1 = 0 ;
31859 int res1 = 0 ;
31860 wxSize temp2 ;
31861 PyObject * obj0 = 0 ;
31862 PyObject * obj1 = 0 ;
31863 char * kwnames[] = {
31864 (char *) "self",(char *) "maxSize", NULL
31865 };
31866
31867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31869 if (!SWIG_IsOK(res1)) {
31870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31871 }
31872 arg1 = reinterpret_cast< wxWindow * >(argp1);
31873 {
31874 arg2 = &temp2;
31875 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31876 }
31877 {
31878 PyThreadState* __tstate = wxPyBeginAllowThreads();
31879 (arg1)->SetMaxSize((wxSize const &)*arg2);
31880 wxPyEndAllowThreads(__tstate);
31881 if (PyErr_Occurred()) SWIG_fail;
31882 }
31883 resultobj = SWIG_Py_Void();
31884 return resultobj;
31885 fail:
31886 return NULL;
31887 }
31888
31889
31890 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31891 PyObject *resultobj = 0;
31892 wxWindow *arg1 = (wxWindow *) 0 ;
31893 int result;
31894 void *argp1 = 0 ;
31895 int res1 = 0 ;
31896 PyObject *swig_obj[1] ;
31897
31898 if (!args) SWIG_fail;
31899 swig_obj[0] = args;
31900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31901 if (!SWIG_IsOK(res1)) {
31902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31903 }
31904 arg1 = reinterpret_cast< wxWindow * >(argp1);
31905 {
31906 PyThreadState* __tstate = wxPyBeginAllowThreads();
31907 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31908 wxPyEndAllowThreads(__tstate);
31909 if (PyErr_Occurred()) SWIG_fail;
31910 }
31911 resultobj = SWIG_From_int(static_cast< int >(result));
31912 return resultobj;
31913 fail:
31914 return NULL;
31915 }
31916
31917
31918 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31919 PyObject *resultobj = 0;
31920 wxWindow *arg1 = (wxWindow *) 0 ;
31921 int result;
31922 void *argp1 = 0 ;
31923 int res1 = 0 ;
31924 PyObject *swig_obj[1] ;
31925
31926 if (!args) SWIG_fail;
31927 swig_obj[0] = args;
31928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31929 if (!SWIG_IsOK(res1)) {
31930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31931 }
31932 arg1 = reinterpret_cast< wxWindow * >(argp1);
31933 {
31934 PyThreadState* __tstate = wxPyBeginAllowThreads();
31935 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31936 wxPyEndAllowThreads(__tstate);
31937 if (PyErr_Occurred()) SWIG_fail;
31938 }
31939 resultobj = SWIG_From_int(static_cast< int >(result));
31940 return resultobj;
31941 fail:
31942 return NULL;
31943 }
31944
31945
31946 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31947 PyObject *resultobj = 0;
31948 wxWindow *arg1 = (wxWindow *) 0 ;
31949 int result;
31950 void *argp1 = 0 ;
31951 int res1 = 0 ;
31952 PyObject *swig_obj[1] ;
31953
31954 if (!args) SWIG_fail;
31955 swig_obj[0] = args;
31956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31957 if (!SWIG_IsOK(res1)) {
31958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31959 }
31960 arg1 = reinterpret_cast< wxWindow * >(argp1);
31961 {
31962 PyThreadState* __tstate = wxPyBeginAllowThreads();
31963 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31964 wxPyEndAllowThreads(__tstate);
31965 if (PyErr_Occurred()) SWIG_fail;
31966 }
31967 resultobj = SWIG_From_int(static_cast< int >(result));
31968 return resultobj;
31969 fail:
31970 return NULL;
31971 }
31972
31973
31974 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31975 PyObject *resultobj = 0;
31976 wxWindow *arg1 = (wxWindow *) 0 ;
31977 int result;
31978 void *argp1 = 0 ;
31979 int res1 = 0 ;
31980 PyObject *swig_obj[1] ;
31981
31982 if (!args) SWIG_fail;
31983 swig_obj[0] = args;
31984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31985 if (!SWIG_IsOK(res1)) {
31986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31987 }
31988 arg1 = reinterpret_cast< wxWindow * >(argp1);
31989 {
31990 PyThreadState* __tstate = wxPyBeginAllowThreads();
31991 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31992 wxPyEndAllowThreads(__tstate);
31993 if (PyErr_Occurred()) SWIG_fail;
31994 }
31995 resultobj = SWIG_From_int(static_cast< int >(result));
31996 return resultobj;
31997 fail:
31998 return NULL;
31999 }
32000
32001
32002 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32003 PyObject *resultobj = 0;
32004 wxWindow *arg1 = (wxWindow *) 0 ;
32005 wxSize *arg2 = 0 ;
32006 void *argp1 = 0 ;
32007 int res1 = 0 ;
32008 wxSize temp2 ;
32009 PyObject * obj0 = 0 ;
32010 PyObject * obj1 = 0 ;
32011 char * kwnames[] = {
32012 (char *) "self",(char *) "size", NULL
32013 };
32014
32015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32017 if (!SWIG_IsOK(res1)) {
32018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32019 }
32020 arg1 = reinterpret_cast< wxWindow * >(argp1);
32021 {
32022 arg2 = &temp2;
32023 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32024 }
32025 {
32026 PyThreadState* __tstate = wxPyBeginAllowThreads();
32027 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32028 wxPyEndAllowThreads(__tstate);
32029 if (PyErr_Occurred()) SWIG_fail;
32030 }
32031 resultobj = SWIG_Py_Void();
32032 return resultobj;
32033 fail:
32034 return NULL;
32035 }
32036
32037
32038 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32039 PyObject *resultobj = 0;
32040 wxWindow *arg1 = (wxWindow *) 0 ;
32041 int arg2 ;
32042 int arg3 ;
32043 void *argp1 = 0 ;
32044 int res1 = 0 ;
32045 int val2 ;
32046 int ecode2 = 0 ;
32047 int val3 ;
32048 int ecode3 = 0 ;
32049 PyObject * obj0 = 0 ;
32050 PyObject * obj1 = 0 ;
32051 PyObject * obj2 = 0 ;
32052 char * kwnames[] = {
32053 (char *) "self",(char *) "w",(char *) "h", NULL
32054 };
32055
32056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32058 if (!SWIG_IsOK(res1)) {
32059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32060 }
32061 arg1 = reinterpret_cast< wxWindow * >(argp1);
32062 ecode2 = SWIG_AsVal_int(obj1, &val2);
32063 if (!SWIG_IsOK(ecode2)) {
32064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32065 }
32066 arg2 = static_cast< int >(val2);
32067 ecode3 = SWIG_AsVal_int(obj2, &val3);
32068 if (!SWIG_IsOK(ecode3)) {
32069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32070 }
32071 arg3 = static_cast< int >(val3);
32072 {
32073 PyThreadState* __tstate = wxPyBeginAllowThreads();
32074 (arg1)->SetVirtualSize(arg2,arg3);
32075 wxPyEndAllowThreads(__tstate);
32076 if (PyErr_Occurred()) SWIG_fail;
32077 }
32078 resultobj = SWIG_Py_Void();
32079 return resultobj;
32080 fail:
32081 return NULL;
32082 }
32083
32084
32085 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32086 PyObject *resultobj = 0;
32087 wxWindow *arg1 = (wxWindow *) 0 ;
32088 wxSize result;
32089 void *argp1 = 0 ;
32090 int res1 = 0 ;
32091 PyObject *swig_obj[1] ;
32092
32093 if (!args) SWIG_fail;
32094 swig_obj[0] = args;
32095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32096 if (!SWIG_IsOK(res1)) {
32097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32098 }
32099 arg1 = reinterpret_cast< wxWindow * >(argp1);
32100 {
32101 PyThreadState* __tstate = wxPyBeginAllowThreads();
32102 result = ((wxWindow const *)arg1)->GetVirtualSize();
32103 wxPyEndAllowThreads(__tstate);
32104 if (PyErr_Occurred()) SWIG_fail;
32105 }
32106 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32107 return resultobj;
32108 fail:
32109 return NULL;
32110 }
32111
32112
32113 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32114 PyObject *resultobj = 0;
32115 wxWindow *arg1 = (wxWindow *) 0 ;
32116 int *arg2 = (int *) 0 ;
32117 int *arg3 = (int *) 0 ;
32118 void *argp1 = 0 ;
32119 int res1 = 0 ;
32120 int temp2 ;
32121 int res2 = SWIG_TMPOBJ ;
32122 int temp3 ;
32123 int res3 = SWIG_TMPOBJ ;
32124 PyObject *swig_obj[1] ;
32125
32126 arg2 = &temp2;
32127 arg3 = &temp3;
32128 if (!args) SWIG_fail;
32129 swig_obj[0] = args;
32130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32131 if (!SWIG_IsOK(res1)) {
32132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32133 }
32134 arg1 = reinterpret_cast< wxWindow * >(argp1);
32135 {
32136 PyThreadState* __tstate = wxPyBeginAllowThreads();
32137 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32138 wxPyEndAllowThreads(__tstate);
32139 if (PyErr_Occurred()) SWIG_fail;
32140 }
32141 resultobj = SWIG_Py_Void();
32142 if (SWIG_IsTmpObj(res2)) {
32143 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32144 } else {
32145 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32146 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32147 }
32148 if (SWIG_IsTmpObj(res3)) {
32149 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32150 } else {
32151 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32152 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32153 }
32154 return resultobj;
32155 fail:
32156 return NULL;
32157 }
32158
32159
32160 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32161 PyObject *resultobj = 0;
32162 wxWindow *arg1 = (wxWindow *) 0 ;
32163 wxSize result;
32164 void *argp1 = 0 ;
32165 int res1 = 0 ;
32166 PyObject *swig_obj[1] ;
32167
32168 if (!args) SWIG_fail;
32169 swig_obj[0] = args;
32170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32171 if (!SWIG_IsOK(res1)) {
32172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32173 }
32174 arg1 = reinterpret_cast< wxWindow * >(argp1);
32175 {
32176 PyThreadState* __tstate = wxPyBeginAllowThreads();
32177 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32178 wxPyEndAllowThreads(__tstate);
32179 if (PyErr_Occurred()) SWIG_fail;
32180 }
32181 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32182 return resultobj;
32183 fail:
32184 return NULL;
32185 }
32186
32187
32188 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32189 PyObject *resultobj = 0;
32190 wxWindow *arg1 = (wxWindow *) 0 ;
32191 bool arg2 = (bool) true ;
32192 bool result;
32193 void *argp1 = 0 ;
32194 int res1 = 0 ;
32195 bool val2 ;
32196 int ecode2 = 0 ;
32197 PyObject * obj0 = 0 ;
32198 PyObject * obj1 = 0 ;
32199 char * kwnames[] = {
32200 (char *) "self",(char *) "show", NULL
32201 };
32202
32203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32205 if (!SWIG_IsOK(res1)) {
32206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32207 }
32208 arg1 = reinterpret_cast< wxWindow * >(argp1);
32209 if (obj1) {
32210 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32211 if (!SWIG_IsOK(ecode2)) {
32212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32213 }
32214 arg2 = static_cast< bool >(val2);
32215 }
32216 {
32217 PyThreadState* __tstate = wxPyBeginAllowThreads();
32218 result = (bool)(arg1)->Show(arg2);
32219 wxPyEndAllowThreads(__tstate);
32220 if (PyErr_Occurred()) SWIG_fail;
32221 }
32222 {
32223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32224 }
32225 return resultobj;
32226 fail:
32227 return NULL;
32228 }
32229
32230
32231 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32232 PyObject *resultobj = 0;
32233 wxWindow *arg1 = (wxWindow *) 0 ;
32234 bool result;
32235 void *argp1 = 0 ;
32236 int res1 = 0 ;
32237 PyObject *swig_obj[1] ;
32238
32239 if (!args) SWIG_fail;
32240 swig_obj[0] = args;
32241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32242 if (!SWIG_IsOK(res1)) {
32243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32244 }
32245 arg1 = reinterpret_cast< wxWindow * >(argp1);
32246 {
32247 PyThreadState* __tstate = wxPyBeginAllowThreads();
32248 result = (bool)(arg1)->Hide();
32249 wxPyEndAllowThreads(__tstate);
32250 if (PyErr_Occurred()) SWIG_fail;
32251 }
32252 {
32253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32254 }
32255 return resultobj;
32256 fail:
32257 return NULL;
32258 }
32259
32260
32261 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32262 PyObject *resultobj = 0;
32263 wxWindow *arg1 = (wxWindow *) 0 ;
32264 bool arg2 = (bool) true ;
32265 bool result;
32266 void *argp1 = 0 ;
32267 int res1 = 0 ;
32268 bool val2 ;
32269 int ecode2 = 0 ;
32270 PyObject * obj0 = 0 ;
32271 PyObject * obj1 = 0 ;
32272 char * kwnames[] = {
32273 (char *) "self",(char *) "enable", NULL
32274 };
32275
32276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32278 if (!SWIG_IsOK(res1)) {
32279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32280 }
32281 arg1 = reinterpret_cast< wxWindow * >(argp1);
32282 if (obj1) {
32283 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32284 if (!SWIG_IsOK(ecode2)) {
32285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32286 }
32287 arg2 = static_cast< bool >(val2);
32288 }
32289 {
32290 PyThreadState* __tstate = wxPyBeginAllowThreads();
32291 result = (bool)(arg1)->Enable(arg2);
32292 wxPyEndAllowThreads(__tstate);
32293 if (PyErr_Occurred()) SWIG_fail;
32294 }
32295 {
32296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32297 }
32298 return resultobj;
32299 fail:
32300 return NULL;
32301 }
32302
32303
32304 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32305 PyObject *resultobj = 0;
32306 wxWindow *arg1 = (wxWindow *) 0 ;
32307 bool result;
32308 void *argp1 = 0 ;
32309 int res1 = 0 ;
32310 PyObject *swig_obj[1] ;
32311
32312 if (!args) SWIG_fail;
32313 swig_obj[0] = args;
32314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32315 if (!SWIG_IsOK(res1)) {
32316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32317 }
32318 arg1 = reinterpret_cast< wxWindow * >(argp1);
32319 {
32320 PyThreadState* __tstate = wxPyBeginAllowThreads();
32321 result = (bool)(arg1)->Disable();
32322 wxPyEndAllowThreads(__tstate);
32323 if (PyErr_Occurred()) SWIG_fail;
32324 }
32325 {
32326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32327 }
32328 return resultobj;
32329 fail:
32330 return NULL;
32331 }
32332
32333
32334 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32335 PyObject *resultobj = 0;
32336 wxWindow *arg1 = (wxWindow *) 0 ;
32337 bool result;
32338 void *argp1 = 0 ;
32339 int res1 = 0 ;
32340 PyObject *swig_obj[1] ;
32341
32342 if (!args) SWIG_fail;
32343 swig_obj[0] = args;
32344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32345 if (!SWIG_IsOK(res1)) {
32346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32347 }
32348 arg1 = reinterpret_cast< wxWindow * >(argp1);
32349 {
32350 PyThreadState* __tstate = wxPyBeginAllowThreads();
32351 result = (bool)((wxWindow const *)arg1)->IsShown();
32352 wxPyEndAllowThreads(__tstate);
32353 if (PyErr_Occurred()) SWIG_fail;
32354 }
32355 {
32356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32357 }
32358 return resultobj;
32359 fail:
32360 return NULL;
32361 }
32362
32363
32364 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32365 PyObject *resultobj = 0;
32366 wxWindow *arg1 = (wxWindow *) 0 ;
32367 bool result;
32368 void *argp1 = 0 ;
32369 int res1 = 0 ;
32370 PyObject *swig_obj[1] ;
32371
32372 if (!args) SWIG_fail;
32373 swig_obj[0] = args;
32374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32375 if (!SWIG_IsOK(res1)) {
32376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32377 }
32378 arg1 = reinterpret_cast< wxWindow * >(argp1);
32379 {
32380 PyThreadState* __tstate = wxPyBeginAllowThreads();
32381 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32382 wxPyEndAllowThreads(__tstate);
32383 if (PyErr_Occurred()) SWIG_fail;
32384 }
32385 {
32386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32387 }
32388 return resultobj;
32389 fail:
32390 return NULL;
32391 }
32392
32393
32394 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32395 PyObject *resultobj = 0;
32396 wxWindow *arg1 = (wxWindow *) 0 ;
32397 long arg2 ;
32398 void *argp1 = 0 ;
32399 int res1 = 0 ;
32400 long val2 ;
32401 int ecode2 = 0 ;
32402 PyObject * obj0 = 0 ;
32403 PyObject * obj1 = 0 ;
32404 char * kwnames[] = {
32405 (char *) "self",(char *) "style", NULL
32406 };
32407
32408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32410 if (!SWIG_IsOK(res1)) {
32411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32412 }
32413 arg1 = reinterpret_cast< wxWindow * >(argp1);
32414 ecode2 = SWIG_AsVal_long(obj1, &val2);
32415 if (!SWIG_IsOK(ecode2)) {
32416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32417 }
32418 arg2 = static_cast< long >(val2);
32419 {
32420 PyThreadState* __tstate = wxPyBeginAllowThreads();
32421 (arg1)->SetWindowStyleFlag(arg2);
32422 wxPyEndAllowThreads(__tstate);
32423 if (PyErr_Occurred()) SWIG_fail;
32424 }
32425 resultobj = SWIG_Py_Void();
32426 return resultobj;
32427 fail:
32428 return NULL;
32429 }
32430
32431
32432 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32433 PyObject *resultobj = 0;
32434 wxWindow *arg1 = (wxWindow *) 0 ;
32435 long result;
32436 void *argp1 = 0 ;
32437 int res1 = 0 ;
32438 PyObject *swig_obj[1] ;
32439
32440 if (!args) SWIG_fail;
32441 swig_obj[0] = args;
32442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32443 if (!SWIG_IsOK(res1)) {
32444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32445 }
32446 arg1 = reinterpret_cast< wxWindow * >(argp1);
32447 {
32448 PyThreadState* __tstate = wxPyBeginAllowThreads();
32449 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32450 wxPyEndAllowThreads(__tstate);
32451 if (PyErr_Occurred()) SWIG_fail;
32452 }
32453 resultobj = SWIG_From_long(static_cast< long >(result));
32454 return resultobj;
32455 fail:
32456 return NULL;
32457 }
32458
32459
32460 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32461 PyObject *resultobj = 0;
32462 wxWindow *arg1 = (wxWindow *) 0 ;
32463 int arg2 ;
32464 bool result;
32465 void *argp1 = 0 ;
32466 int res1 = 0 ;
32467 int val2 ;
32468 int ecode2 = 0 ;
32469 PyObject * obj0 = 0 ;
32470 PyObject * obj1 = 0 ;
32471 char * kwnames[] = {
32472 (char *) "self",(char *) "flag", NULL
32473 };
32474
32475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32477 if (!SWIG_IsOK(res1)) {
32478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32479 }
32480 arg1 = reinterpret_cast< wxWindow * >(argp1);
32481 ecode2 = SWIG_AsVal_int(obj1, &val2);
32482 if (!SWIG_IsOK(ecode2)) {
32483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32484 }
32485 arg2 = static_cast< int >(val2);
32486 {
32487 PyThreadState* __tstate = wxPyBeginAllowThreads();
32488 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32489 wxPyEndAllowThreads(__tstate);
32490 if (PyErr_Occurred()) SWIG_fail;
32491 }
32492 {
32493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32494 }
32495 return resultobj;
32496 fail:
32497 return NULL;
32498 }
32499
32500
32501 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32502 PyObject *resultobj = 0;
32503 wxWindow *arg1 = (wxWindow *) 0 ;
32504 bool result;
32505 void *argp1 = 0 ;
32506 int res1 = 0 ;
32507 PyObject *swig_obj[1] ;
32508
32509 if (!args) SWIG_fail;
32510 swig_obj[0] = args;
32511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32512 if (!SWIG_IsOK(res1)) {
32513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32514 }
32515 arg1 = reinterpret_cast< wxWindow * >(argp1);
32516 {
32517 PyThreadState* __tstate = wxPyBeginAllowThreads();
32518 result = (bool)((wxWindow const *)arg1)->IsRetained();
32519 wxPyEndAllowThreads(__tstate);
32520 if (PyErr_Occurred()) SWIG_fail;
32521 }
32522 {
32523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32524 }
32525 return resultobj;
32526 fail:
32527 return NULL;
32528 }
32529
32530
32531 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32532 PyObject *resultobj = 0;
32533 wxWindow *arg1 = (wxWindow *) 0 ;
32534 long arg2 ;
32535 void *argp1 = 0 ;
32536 int res1 = 0 ;
32537 long val2 ;
32538 int ecode2 = 0 ;
32539 PyObject * obj0 = 0 ;
32540 PyObject * obj1 = 0 ;
32541 char * kwnames[] = {
32542 (char *) "self",(char *) "exStyle", NULL
32543 };
32544
32545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32547 if (!SWIG_IsOK(res1)) {
32548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32549 }
32550 arg1 = reinterpret_cast< wxWindow * >(argp1);
32551 ecode2 = SWIG_AsVal_long(obj1, &val2);
32552 if (!SWIG_IsOK(ecode2)) {
32553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32554 }
32555 arg2 = static_cast< long >(val2);
32556 {
32557 PyThreadState* __tstate = wxPyBeginAllowThreads();
32558 (arg1)->SetExtraStyle(arg2);
32559 wxPyEndAllowThreads(__tstate);
32560 if (PyErr_Occurred()) SWIG_fail;
32561 }
32562 resultobj = SWIG_Py_Void();
32563 return resultobj;
32564 fail:
32565 return NULL;
32566 }
32567
32568
32569 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32570 PyObject *resultobj = 0;
32571 wxWindow *arg1 = (wxWindow *) 0 ;
32572 long result;
32573 void *argp1 = 0 ;
32574 int res1 = 0 ;
32575 PyObject *swig_obj[1] ;
32576
32577 if (!args) SWIG_fail;
32578 swig_obj[0] = args;
32579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32580 if (!SWIG_IsOK(res1)) {
32581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32582 }
32583 arg1 = reinterpret_cast< wxWindow * >(argp1);
32584 {
32585 PyThreadState* __tstate = wxPyBeginAllowThreads();
32586 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32587 wxPyEndAllowThreads(__tstate);
32588 if (PyErr_Occurred()) SWIG_fail;
32589 }
32590 resultobj = SWIG_From_long(static_cast< long >(result));
32591 return resultobj;
32592 fail:
32593 return NULL;
32594 }
32595
32596
32597 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32598 PyObject *resultobj = 0;
32599 wxWindow *arg1 = (wxWindow *) 0 ;
32600 bool arg2 = (bool) true ;
32601 void *argp1 = 0 ;
32602 int res1 = 0 ;
32603 bool val2 ;
32604 int ecode2 = 0 ;
32605 PyObject * obj0 = 0 ;
32606 PyObject * obj1 = 0 ;
32607 char * kwnames[] = {
32608 (char *) "self",(char *) "modal", NULL
32609 };
32610
32611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32613 if (!SWIG_IsOK(res1)) {
32614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32615 }
32616 arg1 = reinterpret_cast< wxWindow * >(argp1);
32617 if (obj1) {
32618 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32619 if (!SWIG_IsOK(ecode2)) {
32620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32621 }
32622 arg2 = static_cast< bool >(val2);
32623 }
32624 {
32625 PyThreadState* __tstate = wxPyBeginAllowThreads();
32626 (arg1)->MakeModal(arg2);
32627 wxPyEndAllowThreads(__tstate);
32628 if (PyErr_Occurred()) SWIG_fail;
32629 }
32630 resultobj = SWIG_Py_Void();
32631 return resultobj;
32632 fail:
32633 return NULL;
32634 }
32635
32636
32637 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32638 PyObject *resultobj = 0;
32639 wxWindow *arg1 = (wxWindow *) 0 ;
32640 bool arg2 ;
32641 void *argp1 = 0 ;
32642 int res1 = 0 ;
32643 bool val2 ;
32644 int ecode2 = 0 ;
32645 PyObject * obj0 = 0 ;
32646 PyObject * obj1 = 0 ;
32647 char * kwnames[] = {
32648 (char *) "self",(char *) "enableTheme", NULL
32649 };
32650
32651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32653 if (!SWIG_IsOK(res1)) {
32654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32655 }
32656 arg1 = reinterpret_cast< wxWindow * >(argp1);
32657 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32658 if (!SWIG_IsOK(ecode2)) {
32659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32660 }
32661 arg2 = static_cast< bool >(val2);
32662 {
32663 PyThreadState* __tstate = wxPyBeginAllowThreads();
32664 (arg1)->SetThemeEnabled(arg2);
32665 wxPyEndAllowThreads(__tstate);
32666 if (PyErr_Occurred()) SWIG_fail;
32667 }
32668 resultobj = SWIG_Py_Void();
32669 return resultobj;
32670 fail:
32671 return NULL;
32672 }
32673
32674
32675 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32676 PyObject *resultobj = 0;
32677 wxWindow *arg1 = (wxWindow *) 0 ;
32678 bool result;
32679 void *argp1 = 0 ;
32680 int res1 = 0 ;
32681 PyObject *swig_obj[1] ;
32682
32683 if (!args) SWIG_fail;
32684 swig_obj[0] = args;
32685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32686 if (!SWIG_IsOK(res1)) {
32687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32688 }
32689 arg1 = reinterpret_cast< wxWindow * >(argp1);
32690 {
32691 PyThreadState* __tstate = wxPyBeginAllowThreads();
32692 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32693 wxPyEndAllowThreads(__tstate);
32694 if (PyErr_Occurred()) SWIG_fail;
32695 }
32696 {
32697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32698 }
32699 return resultobj;
32700 fail:
32701 return NULL;
32702 }
32703
32704
32705 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32706 PyObject *resultobj = 0;
32707 wxWindow *arg1 = (wxWindow *) 0 ;
32708 void *argp1 = 0 ;
32709 int res1 = 0 ;
32710 PyObject *swig_obj[1] ;
32711
32712 if (!args) SWIG_fail;
32713 swig_obj[0] = args;
32714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32715 if (!SWIG_IsOK(res1)) {
32716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32717 }
32718 arg1 = reinterpret_cast< wxWindow * >(argp1);
32719 {
32720 PyThreadState* __tstate = wxPyBeginAllowThreads();
32721 (arg1)->SetFocus();
32722 wxPyEndAllowThreads(__tstate);
32723 if (PyErr_Occurred()) SWIG_fail;
32724 }
32725 resultobj = SWIG_Py_Void();
32726 return resultobj;
32727 fail:
32728 return NULL;
32729 }
32730
32731
32732 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32733 PyObject *resultobj = 0;
32734 wxWindow *arg1 = (wxWindow *) 0 ;
32735 void *argp1 = 0 ;
32736 int res1 = 0 ;
32737 PyObject *swig_obj[1] ;
32738
32739 if (!args) SWIG_fail;
32740 swig_obj[0] = args;
32741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32742 if (!SWIG_IsOK(res1)) {
32743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32744 }
32745 arg1 = reinterpret_cast< wxWindow * >(argp1);
32746 {
32747 PyThreadState* __tstate = wxPyBeginAllowThreads();
32748 (arg1)->SetFocusFromKbd();
32749 wxPyEndAllowThreads(__tstate);
32750 if (PyErr_Occurred()) SWIG_fail;
32751 }
32752 resultobj = SWIG_Py_Void();
32753 return resultobj;
32754 fail:
32755 return NULL;
32756 }
32757
32758
32759 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32760 PyObject *resultobj = 0;
32761 wxWindow *result = 0 ;
32762
32763 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32764 {
32765 if (!wxPyCheckForApp()) SWIG_fail;
32766 PyThreadState* __tstate = wxPyBeginAllowThreads();
32767 result = (wxWindow *)wxWindow::FindFocus();
32768 wxPyEndAllowThreads(__tstate);
32769 if (PyErr_Occurred()) SWIG_fail;
32770 }
32771 {
32772 resultobj = wxPyMake_wxObject(result, 0);
32773 }
32774 return resultobj;
32775 fail:
32776 return NULL;
32777 }
32778
32779
32780 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32781 PyObject *resultobj = 0;
32782 wxWindow *arg1 = (wxWindow *) 0 ;
32783 bool result;
32784 void *argp1 = 0 ;
32785 int res1 = 0 ;
32786 PyObject *swig_obj[1] ;
32787
32788 if (!args) SWIG_fail;
32789 swig_obj[0] = args;
32790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32791 if (!SWIG_IsOK(res1)) {
32792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32793 }
32794 arg1 = reinterpret_cast< wxWindow * >(argp1);
32795 {
32796 PyThreadState* __tstate = wxPyBeginAllowThreads();
32797 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32798 wxPyEndAllowThreads(__tstate);
32799 if (PyErr_Occurred()) SWIG_fail;
32800 }
32801 {
32802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32803 }
32804 return resultobj;
32805 fail:
32806 return NULL;
32807 }
32808
32809
32810 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32811 PyObject *resultobj = 0;
32812 wxWindow *arg1 = (wxWindow *) 0 ;
32813 bool result;
32814 void *argp1 = 0 ;
32815 int res1 = 0 ;
32816 PyObject *swig_obj[1] ;
32817
32818 if (!args) SWIG_fail;
32819 swig_obj[0] = args;
32820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32821 if (!SWIG_IsOK(res1)) {
32822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32823 }
32824 arg1 = reinterpret_cast< wxWindow * >(argp1);
32825 {
32826 PyThreadState* __tstate = wxPyBeginAllowThreads();
32827 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32828 wxPyEndAllowThreads(__tstate);
32829 if (PyErr_Occurred()) SWIG_fail;
32830 }
32831 {
32832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32833 }
32834 return resultobj;
32835 fail:
32836 return NULL;
32837 }
32838
32839
32840 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32841 PyObject *resultobj = 0;
32842 wxWindow *arg1 = (wxWindow *) 0 ;
32843 wxWindow *result = 0 ;
32844 void *argp1 = 0 ;
32845 int res1 = 0 ;
32846 PyObject *swig_obj[1] ;
32847
32848 if (!args) SWIG_fail;
32849 swig_obj[0] = args;
32850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32851 if (!SWIG_IsOK(res1)) {
32852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32853 }
32854 arg1 = reinterpret_cast< wxWindow * >(argp1);
32855 {
32856 PyThreadState* __tstate = wxPyBeginAllowThreads();
32857 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32858 wxPyEndAllowThreads(__tstate);
32859 if (PyErr_Occurred()) SWIG_fail;
32860 }
32861 {
32862 resultobj = wxPyMake_wxObject(result, 0);
32863 }
32864 return resultobj;
32865 fail:
32866 return NULL;
32867 }
32868
32869
32870 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32871 PyObject *resultobj = 0;
32872 wxWindow *arg1 = (wxWindow *) 0 ;
32873 wxWindow *arg2 = (wxWindow *) 0 ;
32874 wxWindow *result = 0 ;
32875 void *argp1 = 0 ;
32876 int res1 = 0 ;
32877 void *argp2 = 0 ;
32878 int res2 = 0 ;
32879 PyObject * obj0 = 0 ;
32880 PyObject * obj1 = 0 ;
32881 char * kwnames[] = {
32882 (char *) "self",(char *) "child", NULL
32883 };
32884
32885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32887 if (!SWIG_IsOK(res1)) {
32888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32889 }
32890 arg1 = reinterpret_cast< wxWindow * >(argp1);
32891 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32892 if (!SWIG_IsOK(res2)) {
32893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32894 }
32895 arg2 = reinterpret_cast< wxWindow * >(argp2);
32896 {
32897 PyThreadState* __tstate = wxPyBeginAllowThreads();
32898 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32899 wxPyEndAllowThreads(__tstate);
32900 if (PyErr_Occurred()) SWIG_fail;
32901 }
32902 {
32903 resultobj = wxPyMake_wxObject(result, 0);
32904 }
32905 return resultobj;
32906 fail:
32907 return NULL;
32908 }
32909
32910
32911 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32912 PyObject *resultobj = 0;
32913 wxWindow *arg1 = (wxWindow *) 0 ;
32914 wxWindow *arg2 = (wxWindow *) 0 ;
32915 void *argp1 = 0 ;
32916 int res1 = 0 ;
32917 void *argp2 = 0 ;
32918 int res2 = 0 ;
32919 PyObject * obj0 = 0 ;
32920 PyObject * obj1 = 0 ;
32921 char * kwnames[] = {
32922 (char *) "self",(char *) "win", NULL
32923 };
32924
32925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32927 if (!SWIG_IsOK(res1)) {
32928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32929 }
32930 arg1 = reinterpret_cast< wxWindow * >(argp1);
32931 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32932 if (!SWIG_IsOK(res2)) {
32933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32934 }
32935 arg2 = reinterpret_cast< wxWindow * >(argp2);
32936 {
32937 PyThreadState* __tstate = wxPyBeginAllowThreads();
32938 (arg1)->SetTmpDefaultItem(arg2);
32939 wxPyEndAllowThreads(__tstate);
32940 if (PyErr_Occurred()) SWIG_fail;
32941 }
32942 resultobj = SWIG_Py_Void();
32943 return resultobj;
32944 fail:
32945 return NULL;
32946 }
32947
32948
32949 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32950 PyObject *resultobj = 0;
32951 wxWindow *arg1 = (wxWindow *) 0 ;
32952 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32953 bool result;
32954 void *argp1 = 0 ;
32955 int res1 = 0 ;
32956 int val2 ;
32957 int ecode2 = 0 ;
32958 PyObject * obj0 = 0 ;
32959 PyObject * obj1 = 0 ;
32960 char * kwnames[] = {
32961 (char *) "self",(char *) "flags", NULL
32962 };
32963
32964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32966 if (!SWIG_IsOK(res1)) {
32967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32968 }
32969 arg1 = reinterpret_cast< wxWindow * >(argp1);
32970 if (obj1) {
32971 ecode2 = SWIG_AsVal_int(obj1, &val2);
32972 if (!SWIG_IsOK(ecode2)) {
32973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32974 }
32975 arg2 = static_cast< int >(val2);
32976 }
32977 {
32978 PyThreadState* __tstate = wxPyBeginAllowThreads();
32979 result = (bool)(arg1)->Navigate(arg2);
32980 wxPyEndAllowThreads(__tstate);
32981 if (PyErr_Occurred()) SWIG_fail;
32982 }
32983 {
32984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32985 }
32986 return resultobj;
32987 fail:
32988 return NULL;
32989 }
32990
32991
32992 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32993 PyObject *resultobj = 0;
32994 wxWindow *arg1 = (wxWindow *) 0 ;
32995 wxWindow *arg2 = (wxWindow *) 0 ;
32996 void *argp1 = 0 ;
32997 int res1 = 0 ;
32998 void *argp2 = 0 ;
32999 int res2 = 0 ;
33000 PyObject * obj0 = 0 ;
33001 PyObject * obj1 = 0 ;
33002 char * kwnames[] = {
33003 (char *) "self",(char *) "win", NULL
33004 };
33005
33006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33008 if (!SWIG_IsOK(res1)) {
33009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33010 }
33011 arg1 = reinterpret_cast< wxWindow * >(argp1);
33012 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33013 if (!SWIG_IsOK(res2)) {
33014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33015 }
33016 arg2 = reinterpret_cast< wxWindow * >(argp2);
33017 {
33018 PyThreadState* __tstate = wxPyBeginAllowThreads();
33019 (arg1)->MoveAfterInTabOrder(arg2);
33020 wxPyEndAllowThreads(__tstate);
33021 if (PyErr_Occurred()) SWIG_fail;
33022 }
33023 resultobj = SWIG_Py_Void();
33024 return resultobj;
33025 fail:
33026 return NULL;
33027 }
33028
33029
33030 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33031 PyObject *resultobj = 0;
33032 wxWindow *arg1 = (wxWindow *) 0 ;
33033 wxWindow *arg2 = (wxWindow *) 0 ;
33034 void *argp1 = 0 ;
33035 int res1 = 0 ;
33036 void *argp2 = 0 ;
33037 int res2 = 0 ;
33038 PyObject * obj0 = 0 ;
33039 PyObject * obj1 = 0 ;
33040 char * kwnames[] = {
33041 (char *) "self",(char *) "win", NULL
33042 };
33043
33044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33046 if (!SWIG_IsOK(res1)) {
33047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33048 }
33049 arg1 = reinterpret_cast< wxWindow * >(argp1);
33050 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33051 if (!SWIG_IsOK(res2)) {
33052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33053 }
33054 arg2 = reinterpret_cast< wxWindow * >(argp2);
33055 {
33056 PyThreadState* __tstate = wxPyBeginAllowThreads();
33057 (arg1)->MoveBeforeInTabOrder(arg2);
33058 wxPyEndAllowThreads(__tstate);
33059 if (PyErr_Occurred()) SWIG_fail;
33060 }
33061 resultobj = SWIG_Py_Void();
33062 return resultobj;
33063 fail:
33064 return NULL;
33065 }
33066
33067
33068 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33069 PyObject *resultobj = 0;
33070 wxWindow *arg1 = (wxWindow *) 0 ;
33071 PyObject *result = 0 ;
33072 void *argp1 = 0 ;
33073 int res1 = 0 ;
33074 PyObject *swig_obj[1] ;
33075
33076 if (!args) SWIG_fail;
33077 swig_obj[0] = args;
33078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33079 if (!SWIG_IsOK(res1)) {
33080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33081 }
33082 arg1 = reinterpret_cast< wxWindow * >(argp1);
33083 {
33084 PyThreadState* __tstate = wxPyBeginAllowThreads();
33085 result = (PyObject *)wxWindow_GetChildren(arg1);
33086 wxPyEndAllowThreads(__tstate);
33087 if (PyErr_Occurred()) SWIG_fail;
33088 }
33089 resultobj = result;
33090 return resultobj;
33091 fail:
33092 return NULL;
33093 }
33094
33095
33096 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33097 PyObject *resultobj = 0;
33098 wxWindow *arg1 = (wxWindow *) 0 ;
33099 wxWindow *result = 0 ;
33100 void *argp1 = 0 ;
33101 int res1 = 0 ;
33102 PyObject *swig_obj[1] ;
33103
33104 if (!args) SWIG_fail;
33105 swig_obj[0] = args;
33106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33107 if (!SWIG_IsOK(res1)) {
33108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33109 }
33110 arg1 = reinterpret_cast< wxWindow * >(argp1);
33111 {
33112 PyThreadState* __tstate = wxPyBeginAllowThreads();
33113 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33114 wxPyEndAllowThreads(__tstate);
33115 if (PyErr_Occurred()) SWIG_fail;
33116 }
33117 {
33118 resultobj = wxPyMake_wxObject(result, 0);
33119 }
33120 return resultobj;
33121 fail:
33122 return NULL;
33123 }
33124
33125
33126 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33127 PyObject *resultobj = 0;
33128 wxWindow *arg1 = (wxWindow *) 0 ;
33129 wxWindow *result = 0 ;
33130 void *argp1 = 0 ;
33131 int res1 = 0 ;
33132 PyObject *swig_obj[1] ;
33133
33134 if (!args) SWIG_fail;
33135 swig_obj[0] = args;
33136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33137 if (!SWIG_IsOK(res1)) {
33138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33139 }
33140 arg1 = reinterpret_cast< wxWindow * >(argp1);
33141 {
33142 PyThreadState* __tstate = wxPyBeginAllowThreads();
33143 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33144 wxPyEndAllowThreads(__tstate);
33145 if (PyErr_Occurred()) SWIG_fail;
33146 }
33147 {
33148 resultobj = wxPyMake_wxObject(result, 0);
33149 }
33150 return resultobj;
33151 fail:
33152 return NULL;
33153 }
33154
33155
33156 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33157 PyObject *resultobj = 0;
33158 wxWindow *arg1 = (wxWindow *) 0 ;
33159 bool result;
33160 void *argp1 = 0 ;
33161 int res1 = 0 ;
33162 PyObject *swig_obj[1] ;
33163
33164 if (!args) SWIG_fail;
33165 swig_obj[0] = args;
33166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33167 if (!SWIG_IsOK(res1)) {
33168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33169 }
33170 arg1 = reinterpret_cast< wxWindow * >(argp1);
33171 {
33172 PyThreadState* __tstate = wxPyBeginAllowThreads();
33173 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33174 wxPyEndAllowThreads(__tstate);
33175 if (PyErr_Occurred()) SWIG_fail;
33176 }
33177 {
33178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33179 }
33180 return resultobj;
33181 fail:
33182 return NULL;
33183 }
33184
33185
33186 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33187 PyObject *resultobj = 0;
33188 wxWindow *arg1 = (wxWindow *) 0 ;
33189 wxWindow *arg2 = (wxWindow *) 0 ;
33190 bool result;
33191 void *argp1 = 0 ;
33192 int res1 = 0 ;
33193 void *argp2 = 0 ;
33194 int res2 = 0 ;
33195 PyObject * obj0 = 0 ;
33196 PyObject * obj1 = 0 ;
33197 char * kwnames[] = {
33198 (char *) "self",(char *) "newParent", NULL
33199 };
33200
33201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33203 if (!SWIG_IsOK(res1)) {
33204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33205 }
33206 arg1 = reinterpret_cast< wxWindow * >(argp1);
33207 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33208 if (!SWIG_IsOK(res2)) {
33209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33210 }
33211 arg2 = reinterpret_cast< wxWindow * >(argp2);
33212 {
33213 PyThreadState* __tstate = wxPyBeginAllowThreads();
33214 result = (bool)(arg1)->Reparent(arg2);
33215 wxPyEndAllowThreads(__tstate);
33216 if (PyErr_Occurred()) SWIG_fail;
33217 }
33218 {
33219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33220 }
33221 return resultobj;
33222 fail:
33223 return NULL;
33224 }
33225
33226
33227 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33228 PyObject *resultobj = 0;
33229 wxWindow *arg1 = (wxWindow *) 0 ;
33230 wxWindow *arg2 = (wxWindow *) 0 ;
33231 void *argp1 = 0 ;
33232 int res1 = 0 ;
33233 void *argp2 = 0 ;
33234 int res2 = 0 ;
33235 PyObject * obj0 = 0 ;
33236 PyObject * obj1 = 0 ;
33237 char * kwnames[] = {
33238 (char *) "self",(char *) "child", NULL
33239 };
33240
33241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33243 if (!SWIG_IsOK(res1)) {
33244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33245 }
33246 arg1 = reinterpret_cast< wxWindow * >(argp1);
33247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33248 if (!SWIG_IsOK(res2)) {
33249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33250 }
33251 arg2 = reinterpret_cast< wxWindow * >(argp2);
33252 {
33253 PyThreadState* __tstate = wxPyBeginAllowThreads();
33254 (arg1)->AddChild(arg2);
33255 wxPyEndAllowThreads(__tstate);
33256 if (PyErr_Occurred()) SWIG_fail;
33257 }
33258 resultobj = SWIG_Py_Void();
33259 return resultobj;
33260 fail:
33261 return NULL;
33262 }
33263
33264
33265 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33266 PyObject *resultobj = 0;
33267 wxWindow *arg1 = (wxWindow *) 0 ;
33268 wxWindow *arg2 = (wxWindow *) 0 ;
33269 void *argp1 = 0 ;
33270 int res1 = 0 ;
33271 void *argp2 = 0 ;
33272 int res2 = 0 ;
33273 PyObject * obj0 = 0 ;
33274 PyObject * obj1 = 0 ;
33275 char * kwnames[] = {
33276 (char *) "self",(char *) "child", NULL
33277 };
33278
33279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33281 if (!SWIG_IsOK(res1)) {
33282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33283 }
33284 arg1 = reinterpret_cast< wxWindow * >(argp1);
33285 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33286 if (!SWIG_IsOK(res2)) {
33287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33288 }
33289 arg2 = reinterpret_cast< wxWindow * >(argp2);
33290 {
33291 PyThreadState* __tstate = wxPyBeginAllowThreads();
33292 (arg1)->RemoveChild(arg2);
33293 wxPyEndAllowThreads(__tstate);
33294 if (PyErr_Occurred()) SWIG_fail;
33295 }
33296 resultobj = SWIG_Py_Void();
33297 return resultobj;
33298 fail:
33299 return NULL;
33300 }
33301
33302
33303 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33304 PyObject *resultobj = 0;
33305 wxWindow *arg1 = (wxWindow *) 0 ;
33306 bool arg2 ;
33307 void *argp1 = 0 ;
33308 int res1 = 0 ;
33309 bool val2 ;
33310 int ecode2 = 0 ;
33311 PyObject * obj0 = 0 ;
33312 PyObject * obj1 = 0 ;
33313 char * kwnames[] = {
33314 (char *) "self",(char *) "on", NULL
33315 };
33316
33317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33319 if (!SWIG_IsOK(res1)) {
33320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33321 }
33322 arg1 = reinterpret_cast< wxWindow * >(argp1);
33323 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33324 if (!SWIG_IsOK(ecode2)) {
33325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33326 }
33327 arg2 = static_cast< bool >(val2);
33328 {
33329 PyThreadState* __tstate = wxPyBeginAllowThreads();
33330 (arg1)->SetDoubleBuffered(arg2);
33331 wxPyEndAllowThreads(__tstate);
33332 if (PyErr_Occurred()) SWIG_fail;
33333 }
33334 resultobj = SWIG_Py_Void();
33335 return resultobj;
33336 fail:
33337 return NULL;
33338 }
33339
33340
33341 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33342 PyObject *resultobj = 0;
33343 wxWindow *arg1 = (wxWindow *) 0 ;
33344 long arg2 ;
33345 wxWindow *result = 0 ;
33346 void *argp1 = 0 ;
33347 int res1 = 0 ;
33348 long val2 ;
33349 int ecode2 = 0 ;
33350 PyObject * obj0 = 0 ;
33351 PyObject * obj1 = 0 ;
33352 char * kwnames[] = {
33353 (char *) "self",(char *) "winid", NULL
33354 };
33355
33356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33358 if (!SWIG_IsOK(res1)) {
33359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33360 }
33361 arg1 = reinterpret_cast< wxWindow * >(argp1);
33362 ecode2 = SWIG_AsVal_long(obj1, &val2);
33363 if (!SWIG_IsOK(ecode2)) {
33364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33365 }
33366 arg2 = static_cast< long >(val2);
33367 {
33368 PyThreadState* __tstate = wxPyBeginAllowThreads();
33369 result = (wxWindow *)(arg1)->FindWindow(arg2);
33370 wxPyEndAllowThreads(__tstate);
33371 if (PyErr_Occurred()) SWIG_fail;
33372 }
33373 {
33374 resultobj = wxPyMake_wxObject(result, 0);
33375 }
33376 return resultobj;
33377 fail:
33378 return NULL;
33379 }
33380
33381
33382 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33383 PyObject *resultobj = 0;
33384 wxWindow *arg1 = (wxWindow *) 0 ;
33385 wxString *arg2 = 0 ;
33386 wxWindow *result = 0 ;
33387 void *argp1 = 0 ;
33388 int res1 = 0 ;
33389 bool temp2 = false ;
33390 PyObject * obj0 = 0 ;
33391 PyObject * obj1 = 0 ;
33392 char * kwnames[] = {
33393 (char *) "self",(char *) "name", NULL
33394 };
33395
33396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33398 if (!SWIG_IsOK(res1)) {
33399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33400 }
33401 arg1 = reinterpret_cast< wxWindow * >(argp1);
33402 {
33403 arg2 = wxString_in_helper(obj1);
33404 if (arg2 == NULL) SWIG_fail;
33405 temp2 = true;
33406 }
33407 {
33408 PyThreadState* __tstate = wxPyBeginAllowThreads();
33409 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33410 wxPyEndAllowThreads(__tstate);
33411 if (PyErr_Occurred()) SWIG_fail;
33412 }
33413 {
33414 resultobj = wxPyMake_wxObject(result, 0);
33415 }
33416 {
33417 if (temp2)
33418 delete arg2;
33419 }
33420 return resultobj;
33421 fail:
33422 {
33423 if (temp2)
33424 delete arg2;
33425 }
33426 return NULL;
33427 }
33428
33429
33430 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33431 PyObject *resultobj = 0;
33432 wxWindow *arg1 = (wxWindow *) 0 ;
33433 wxEvtHandler *result = 0 ;
33434 void *argp1 = 0 ;
33435 int res1 = 0 ;
33436 PyObject *swig_obj[1] ;
33437
33438 if (!args) SWIG_fail;
33439 swig_obj[0] = args;
33440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33441 if (!SWIG_IsOK(res1)) {
33442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33443 }
33444 arg1 = reinterpret_cast< wxWindow * >(argp1);
33445 {
33446 PyThreadState* __tstate = wxPyBeginAllowThreads();
33447 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33448 wxPyEndAllowThreads(__tstate);
33449 if (PyErr_Occurred()) SWIG_fail;
33450 }
33451 {
33452 resultobj = wxPyMake_wxObject(result, 0);
33453 }
33454 return resultobj;
33455 fail:
33456 return NULL;
33457 }
33458
33459
33460 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33461 PyObject *resultobj = 0;
33462 wxWindow *arg1 = (wxWindow *) 0 ;
33463 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33464 void *argp1 = 0 ;
33465 int res1 = 0 ;
33466 void *argp2 = 0 ;
33467 int res2 = 0 ;
33468 PyObject * obj0 = 0 ;
33469 PyObject * obj1 = 0 ;
33470 char * kwnames[] = {
33471 (char *) "self",(char *) "handler", NULL
33472 };
33473
33474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33476 if (!SWIG_IsOK(res1)) {
33477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33478 }
33479 arg1 = reinterpret_cast< wxWindow * >(argp1);
33480 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33481 if (!SWIG_IsOK(res2)) {
33482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33483 }
33484 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33485 {
33486 PyThreadState* __tstate = wxPyBeginAllowThreads();
33487 (arg1)->SetEventHandler(arg2);
33488 wxPyEndAllowThreads(__tstate);
33489 if (PyErr_Occurred()) SWIG_fail;
33490 }
33491 resultobj = SWIG_Py_Void();
33492 return resultobj;
33493 fail:
33494 return NULL;
33495 }
33496
33497
33498 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33499 PyObject *resultobj = 0;
33500 wxWindow *arg1 = (wxWindow *) 0 ;
33501 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33502 void *argp1 = 0 ;
33503 int res1 = 0 ;
33504 void *argp2 = 0 ;
33505 int res2 = 0 ;
33506 PyObject * obj0 = 0 ;
33507 PyObject * obj1 = 0 ;
33508 char * kwnames[] = {
33509 (char *) "self",(char *) "handler", NULL
33510 };
33511
33512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33514 if (!SWIG_IsOK(res1)) {
33515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33516 }
33517 arg1 = reinterpret_cast< wxWindow * >(argp1);
33518 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33519 if (!SWIG_IsOK(res2)) {
33520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33521 }
33522 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33523 {
33524 PyThreadState* __tstate = wxPyBeginAllowThreads();
33525 (arg1)->PushEventHandler(arg2);
33526 wxPyEndAllowThreads(__tstate);
33527 if (PyErr_Occurred()) SWIG_fail;
33528 }
33529 resultobj = SWIG_Py_Void();
33530 return resultobj;
33531 fail:
33532 return NULL;
33533 }
33534
33535
33536 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33537 PyObject *resultobj = 0;
33538 wxWindow *arg1 = (wxWindow *) 0 ;
33539 bool arg2 = (bool) false ;
33540 wxEvtHandler *result = 0 ;
33541 void *argp1 = 0 ;
33542 int res1 = 0 ;
33543 bool val2 ;
33544 int ecode2 = 0 ;
33545 PyObject * obj0 = 0 ;
33546 PyObject * obj1 = 0 ;
33547 char * kwnames[] = {
33548 (char *) "self",(char *) "deleteHandler", NULL
33549 };
33550
33551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33553 if (!SWIG_IsOK(res1)) {
33554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33555 }
33556 arg1 = reinterpret_cast< wxWindow * >(argp1);
33557 if (obj1) {
33558 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33559 if (!SWIG_IsOK(ecode2)) {
33560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33561 }
33562 arg2 = static_cast< bool >(val2);
33563 }
33564 {
33565 PyThreadState* __tstate = wxPyBeginAllowThreads();
33566 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33567 wxPyEndAllowThreads(__tstate);
33568 if (PyErr_Occurred()) SWIG_fail;
33569 }
33570 {
33571 resultobj = wxPyMake_wxObject(result, 0);
33572 }
33573 return resultobj;
33574 fail:
33575 return NULL;
33576 }
33577
33578
33579 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33580 PyObject *resultobj = 0;
33581 wxWindow *arg1 = (wxWindow *) 0 ;
33582 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33583 bool result;
33584 void *argp1 = 0 ;
33585 int res1 = 0 ;
33586 void *argp2 = 0 ;
33587 int res2 = 0 ;
33588 PyObject * obj0 = 0 ;
33589 PyObject * obj1 = 0 ;
33590 char * kwnames[] = {
33591 (char *) "self",(char *) "handler", NULL
33592 };
33593
33594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33596 if (!SWIG_IsOK(res1)) {
33597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33598 }
33599 arg1 = reinterpret_cast< wxWindow * >(argp1);
33600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33601 if (!SWIG_IsOK(res2)) {
33602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33603 }
33604 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33605 {
33606 PyThreadState* __tstate = wxPyBeginAllowThreads();
33607 result = (bool)(arg1)->RemoveEventHandler(arg2);
33608 wxPyEndAllowThreads(__tstate);
33609 if (PyErr_Occurred()) SWIG_fail;
33610 }
33611 {
33612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33613 }
33614 return resultobj;
33615 fail:
33616 return NULL;
33617 }
33618
33619
33620 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33621 PyObject *resultobj = 0;
33622 wxWindow *arg1 = (wxWindow *) 0 ;
33623 wxValidator *arg2 = 0 ;
33624 void *argp1 = 0 ;
33625 int res1 = 0 ;
33626 void *argp2 = 0 ;
33627 int res2 = 0 ;
33628 PyObject * obj0 = 0 ;
33629 PyObject * obj1 = 0 ;
33630 char * kwnames[] = {
33631 (char *) "self",(char *) "validator", NULL
33632 };
33633
33634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33636 if (!SWIG_IsOK(res1)) {
33637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33638 }
33639 arg1 = reinterpret_cast< wxWindow * >(argp1);
33640 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33641 if (!SWIG_IsOK(res2)) {
33642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33643 }
33644 if (!argp2) {
33645 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33646 }
33647 arg2 = reinterpret_cast< wxValidator * >(argp2);
33648 {
33649 PyThreadState* __tstate = wxPyBeginAllowThreads();
33650 (arg1)->SetValidator((wxValidator const &)*arg2);
33651 wxPyEndAllowThreads(__tstate);
33652 if (PyErr_Occurred()) SWIG_fail;
33653 }
33654 resultobj = SWIG_Py_Void();
33655 return resultobj;
33656 fail:
33657 return NULL;
33658 }
33659
33660
33661 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33662 PyObject *resultobj = 0;
33663 wxWindow *arg1 = (wxWindow *) 0 ;
33664 wxValidator *result = 0 ;
33665 void *argp1 = 0 ;
33666 int res1 = 0 ;
33667 PyObject *swig_obj[1] ;
33668
33669 if (!args) SWIG_fail;
33670 swig_obj[0] = args;
33671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33672 if (!SWIG_IsOK(res1)) {
33673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33674 }
33675 arg1 = reinterpret_cast< wxWindow * >(argp1);
33676 {
33677 PyThreadState* __tstate = wxPyBeginAllowThreads();
33678 result = (wxValidator *)(arg1)->GetValidator();
33679 wxPyEndAllowThreads(__tstate);
33680 if (PyErr_Occurred()) SWIG_fail;
33681 }
33682 {
33683 resultobj = wxPyMake_wxObject(result, (bool)0);
33684 }
33685 return resultobj;
33686 fail:
33687 return NULL;
33688 }
33689
33690
33691 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33692 PyObject *resultobj = 0;
33693 wxWindow *arg1 = (wxWindow *) 0 ;
33694 bool result;
33695 void *argp1 = 0 ;
33696 int res1 = 0 ;
33697 PyObject *swig_obj[1] ;
33698
33699 if (!args) SWIG_fail;
33700 swig_obj[0] = args;
33701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33702 if (!SWIG_IsOK(res1)) {
33703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33704 }
33705 arg1 = reinterpret_cast< wxWindow * >(argp1);
33706 {
33707 PyThreadState* __tstate = wxPyBeginAllowThreads();
33708 result = (bool)(arg1)->Validate();
33709 wxPyEndAllowThreads(__tstate);
33710 if (PyErr_Occurred()) SWIG_fail;
33711 }
33712 {
33713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33714 }
33715 return resultobj;
33716 fail:
33717 return NULL;
33718 }
33719
33720
33721 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33722 PyObject *resultobj = 0;
33723 wxWindow *arg1 = (wxWindow *) 0 ;
33724 bool result;
33725 void *argp1 = 0 ;
33726 int res1 = 0 ;
33727 PyObject *swig_obj[1] ;
33728
33729 if (!args) SWIG_fail;
33730 swig_obj[0] = args;
33731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33732 if (!SWIG_IsOK(res1)) {
33733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33734 }
33735 arg1 = reinterpret_cast< wxWindow * >(argp1);
33736 {
33737 PyThreadState* __tstate = wxPyBeginAllowThreads();
33738 result = (bool)(arg1)->TransferDataToWindow();
33739 wxPyEndAllowThreads(__tstate);
33740 if (PyErr_Occurred()) SWIG_fail;
33741 }
33742 {
33743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33744 }
33745 return resultobj;
33746 fail:
33747 return NULL;
33748 }
33749
33750
33751 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33752 PyObject *resultobj = 0;
33753 wxWindow *arg1 = (wxWindow *) 0 ;
33754 bool result;
33755 void *argp1 = 0 ;
33756 int res1 = 0 ;
33757 PyObject *swig_obj[1] ;
33758
33759 if (!args) SWIG_fail;
33760 swig_obj[0] = args;
33761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33762 if (!SWIG_IsOK(res1)) {
33763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33764 }
33765 arg1 = reinterpret_cast< wxWindow * >(argp1);
33766 {
33767 PyThreadState* __tstate = wxPyBeginAllowThreads();
33768 result = (bool)(arg1)->TransferDataFromWindow();
33769 wxPyEndAllowThreads(__tstate);
33770 if (PyErr_Occurred()) SWIG_fail;
33771 }
33772 {
33773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33774 }
33775 return resultobj;
33776 fail:
33777 return NULL;
33778 }
33779
33780
33781 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33782 PyObject *resultobj = 0;
33783 wxWindow *arg1 = (wxWindow *) 0 ;
33784 void *argp1 = 0 ;
33785 int res1 = 0 ;
33786 PyObject *swig_obj[1] ;
33787
33788 if (!args) SWIG_fail;
33789 swig_obj[0] = args;
33790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33791 if (!SWIG_IsOK(res1)) {
33792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33793 }
33794 arg1 = reinterpret_cast< wxWindow * >(argp1);
33795 {
33796 PyThreadState* __tstate = wxPyBeginAllowThreads();
33797 (arg1)->InitDialog();
33798 wxPyEndAllowThreads(__tstate);
33799 if (PyErr_Occurred()) SWIG_fail;
33800 }
33801 resultobj = SWIG_Py_Void();
33802 return resultobj;
33803 fail:
33804 return NULL;
33805 }
33806
33807
33808 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33809 PyObject *resultobj = 0;
33810 wxWindow *arg1 = (wxWindow *) 0 ;
33811 wxAcceleratorTable *arg2 = 0 ;
33812 void *argp1 = 0 ;
33813 int res1 = 0 ;
33814 void *argp2 = 0 ;
33815 int res2 = 0 ;
33816 PyObject * obj0 = 0 ;
33817 PyObject * obj1 = 0 ;
33818 char * kwnames[] = {
33819 (char *) "self",(char *) "accel", NULL
33820 };
33821
33822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33824 if (!SWIG_IsOK(res1)) {
33825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33826 }
33827 arg1 = reinterpret_cast< wxWindow * >(argp1);
33828 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33829 if (!SWIG_IsOK(res2)) {
33830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33831 }
33832 if (!argp2) {
33833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33834 }
33835 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33836 {
33837 PyThreadState* __tstate = wxPyBeginAllowThreads();
33838 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33839 wxPyEndAllowThreads(__tstate);
33840 if (PyErr_Occurred()) SWIG_fail;
33841 }
33842 resultobj = SWIG_Py_Void();
33843 return resultobj;
33844 fail:
33845 return NULL;
33846 }
33847
33848
33849 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33850 PyObject *resultobj = 0;
33851 wxWindow *arg1 = (wxWindow *) 0 ;
33852 wxAcceleratorTable *result = 0 ;
33853 void *argp1 = 0 ;
33854 int res1 = 0 ;
33855 PyObject *swig_obj[1] ;
33856
33857 if (!args) SWIG_fail;
33858 swig_obj[0] = args;
33859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33860 if (!SWIG_IsOK(res1)) {
33861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33862 }
33863 arg1 = reinterpret_cast< wxWindow * >(argp1);
33864 {
33865 PyThreadState* __tstate = wxPyBeginAllowThreads();
33866 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33867 wxPyEndAllowThreads(__tstate);
33868 if (PyErr_Occurred()) SWIG_fail;
33869 }
33870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33871 return resultobj;
33872 fail:
33873 return NULL;
33874 }
33875
33876
33877 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33878 PyObject *resultobj = 0;
33879 wxWindow *arg1 = (wxWindow *) 0 ;
33880 int arg2 ;
33881 int arg3 ;
33882 int arg4 ;
33883 bool result;
33884 void *argp1 = 0 ;
33885 int res1 = 0 ;
33886 int val2 ;
33887 int ecode2 = 0 ;
33888 int val3 ;
33889 int ecode3 = 0 ;
33890 int val4 ;
33891 int ecode4 = 0 ;
33892 PyObject * obj0 = 0 ;
33893 PyObject * obj1 = 0 ;
33894 PyObject * obj2 = 0 ;
33895 PyObject * obj3 = 0 ;
33896 char * kwnames[] = {
33897 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33898 };
33899
33900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33902 if (!SWIG_IsOK(res1)) {
33903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33904 }
33905 arg1 = reinterpret_cast< wxWindow * >(argp1);
33906 ecode2 = SWIG_AsVal_int(obj1, &val2);
33907 if (!SWIG_IsOK(ecode2)) {
33908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33909 }
33910 arg2 = static_cast< int >(val2);
33911 ecode3 = SWIG_AsVal_int(obj2, &val3);
33912 if (!SWIG_IsOK(ecode3)) {
33913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33914 }
33915 arg3 = static_cast< int >(val3);
33916 ecode4 = SWIG_AsVal_int(obj3, &val4);
33917 if (!SWIG_IsOK(ecode4)) {
33918 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33919 }
33920 arg4 = static_cast< int >(val4);
33921 {
33922 PyThreadState* __tstate = wxPyBeginAllowThreads();
33923 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33924 wxPyEndAllowThreads(__tstate);
33925 if (PyErr_Occurred()) SWIG_fail;
33926 }
33927 {
33928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33929 }
33930 return resultobj;
33931 fail:
33932 return NULL;
33933 }
33934
33935
33936 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33937 PyObject *resultobj = 0;
33938 wxWindow *arg1 = (wxWindow *) 0 ;
33939 int arg2 ;
33940 bool result;
33941 void *argp1 = 0 ;
33942 int res1 = 0 ;
33943 int val2 ;
33944 int ecode2 = 0 ;
33945 PyObject * obj0 = 0 ;
33946 PyObject * obj1 = 0 ;
33947 char * kwnames[] = {
33948 (char *) "self",(char *) "hotkeyId", NULL
33949 };
33950
33951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33953 if (!SWIG_IsOK(res1)) {
33954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33955 }
33956 arg1 = reinterpret_cast< wxWindow * >(argp1);
33957 ecode2 = SWIG_AsVal_int(obj1, &val2);
33958 if (!SWIG_IsOK(ecode2)) {
33959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33960 }
33961 arg2 = static_cast< int >(val2);
33962 {
33963 PyThreadState* __tstate = wxPyBeginAllowThreads();
33964 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33965 wxPyEndAllowThreads(__tstate);
33966 if (PyErr_Occurred()) SWIG_fail;
33967 }
33968 {
33969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33970 }
33971 return resultobj;
33972 fail:
33973 return NULL;
33974 }
33975
33976
33977 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33978 PyObject *resultobj = 0;
33979 wxWindow *arg1 = (wxWindow *) 0 ;
33980 wxPoint *arg2 = 0 ;
33981 wxPoint result;
33982 void *argp1 = 0 ;
33983 int res1 = 0 ;
33984 wxPoint temp2 ;
33985 PyObject * obj0 = 0 ;
33986 PyObject * obj1 = 0 ;
33987 char * kwnames[] = {
33988 (char *) "self",(char *) "pt", NULL
33989 };
33990
33991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33993 if (!SWIG_IsOK(res1)) {
33994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33995 }
33996 arg1 = reinterpret_cast< wxWindow * >(argp1);
33997 {
33998 arg2 = &temp2;
33999 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34000 }
34001 {
34002 PyThreadState* __tstate = wxPyBeginAllowThreads();
34003 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34004 wxPyEndAllowThreads(__tstate);
34005 if (PyErr_Occurred()) SWIG_fail;
34006 }
34007 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34008 return resultobj;
34009 fail:
34010 return NULL;
34011 }
34012
34013
34014 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34015 PyObject *resultobj = 0;
34016 wxWindow *arg1 = (wxWindow *) 0 ;
34017 wxSize *arg2 = 0 ;
34018 wxSize result;
34019 void *argp1 = 0 ;
34020 int res1 = 0 ;
34021 wxSize temp2 ;
34022 PyObject * obj0 = 0 ;
34023 PyObject * obj1 = 0 ;
34024 char * kwnames[] = {
34025 (char *) "self",(char *) "sz", NULL
34026 };
34027
34028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34030 if (!SWIG_IsOK(res1)) {
34031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34032 }
34033 arg1 = reinterpret_cast< wxWindow * >(argp1);
34034 {
34035 arg2 = &temp2;
34036 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34037 }
34038 {
34039 PyThreadState* __tstate = wxPyBeginAllowThreads();
34040 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34041 wxPyEndAllowThreads(__tstate);
34042 if (PyErr_Occurred()) SWIG_fail;
34043 }
34044 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34045 return resultobj;
34046 fail:
34047 return NULL;
34048 }
34049
34050
34051 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34052 PyObject *resultobj = 0;
34053 wxWindow *arg1 = (wxWindow *) 0 ;
34054 wxPoint *arg2 = 0 ;
34055 wxPoint result;
34056 void *argp1 = 0 ;
34057 int res1 = 0 ;
34058 wxPoint temp2 ;
34059 PyObject * obj0 = 0 ;
34060 PyObject * obj1 = 0 ;
34061 char * kwnames[] = {
34062 (char *) "self",(char *) "pt", NULL
34063 };
34064
34065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34067 if (!SWIG_IsOK(res1)) {
34068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34069 }
34070 arg1 = reinterpret_cast< wxWindow * >(argp1);
34071 {
34072 arg2 = &temp2;
34073 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34074 }
34075 {
34076 PyThreadState* __tstate = wxPyBeginAllowThreads();
34077 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34078 wxPyEndAllowThreads(__tstate);
34079 if (PyErr_Occurred()) SWIG_fail;
34080 }
34081 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34082 return resultobj;
34083 fail:
34084 return NULL;
34085 }
34086
34087
34088 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34089 PyObject *resultobj = 0;
34090 wxWindow *arg1 = (wxWindow *) 0 ;
34091 wxSize *arg2 = 0 ;
34092 wxSize result;
34093 void *argp1 = 0 ;
34094 int res1 = 0 ;
34095 wxSize temp2 ;
34096 PyObject * obj0 = 0 ;
34097 PyObject * obj1 = 0 ;
34098 char * kwnames[] = {
34099 (char *) "self",(char *) "sz", NULL
34100 };
34101
34102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34104 if (!SWIG_IsOK(res1)) {
34105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34106 }
34107 arg1 = reinterpret_cast< wxWindow * >(argp1);
34108 {
34109 arg2 = &temp2;
34110 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34111 }
34112 {
34113 PyThreadState* __tstate = wxPyBeginAllowThreads();
34114 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34115 wxPyEndAllowThreads(__tstate);
34116 if (PyErr_Occurred()) SWIG_fail;
34117 }
34118 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34119 return resultobj;
34120 fail:
34121 return NULL;
34122 }
34123
34124
34125 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34126 PyObject *resultobj = 0;
34127 wxWindow *arg1 = (wxWindow *) 0 ;
34128 wxPoint *arg2 = 0 ;
34129 wxPoint result;
34130 void *argp1 = 0 ;
34131 int res1 = 0 ;
34132 wxPoint temp2 ;
34133 PyObject * obj0 = 0 ;
34134 PyObject * obj1 = 0 ;
34135 char * kwnames[] = {
34136 (char *) "self",(char *) "pt", NULL
34137 };
34138
34139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34141 if (!SWIG_IsOK(res1)) {
34142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34143 }
34144 arg1 = reinterpret_cast< wxWindow * >(argp1);
34145 {
34146 arg2 = &temp2;
34147 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34148 }
34149 {
34150 PyThreadState* __tstate = wxPyBeginAllowThreads();
34151 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34152 wxPyEndAllowThreads(__tstate);
34153 if (PyErr_Occurred()) SWIG_fail;
34154 }
34155 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34156 return resultobj;
34157 fail:
34158 return NULL;
34159 }
34160
34161
34162 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34163 PyObject *resultobj = 0;
34164 wxWindow *arg1 = (wxWindow *) 0 ;
34165 wxSize *arg2 = 0 ;
34166 wxSize result;
34167 void *argp1 = 0 ;
34168 int res1 = 0 ;
34169 wxSize temp2 ;
34170 PyObject * obj0 = 0 ;
34171 PyObject * obj1 = 0 ;
34172 char * kwnames[] = {
34173 (char *) "self",(char *) "sz", NULL
34174 };
34175
34176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34178 if (!SWIG_IsOK(res1)) {
34179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34180 }
34181 arg1 = reinterpret_cast< wxWindow * >(argp1);
34182 {
34183 arg2 = &temp2;
34184 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34185 }
34186 {
34187 PyThreadState* __tstate = wxPyBeginAllowThreads();
34188 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34189 wxPyEndAllowThreads(__tstate);
34190 if (PyErr_Occurred()) SWIG_fail;
34191 }
34192 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34193 return resultobj;
34194 fail:
34195 return NULL;
34196 }
34197
34198
34199 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34200 PyObject *resultobj = 0;
34201 wxWindow *arg1 = (wxWindow *) 0 ;
34202 int arg2 ;
34203 int arg3 ;
34204 void *argp1 = 0 ;
34205 int res1 = 0 ;
34206 int val2 ;
34207 int ecode2 = 0 ;
34208 int val3 ;
34209 int ecode3 = 0 ;
34210 PyObject * obj0 = 0 ;
34211 PyObject * obj1 = 0 ;
34212 PyObject * obj2 = 0 ;
34213 char * kwnames[] = {
34214 (char *) "self",(char *) "x",(char *) "y", NULL
34215 };
34216
34217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34219 if (!SWIG_IsOK(res1)) {
34220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34221 }
34222 arg1 = reinterpret_cast< wxWindow * >(argp1);
34223 ecode2 = SWIG_AsVal_int(obj1, &val2);
34224 if (!SWIG_IsOK(ecode2)) {
34225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34226 }
34227 arg2 = static_cast< int >(val2);
34228 ecode3 = SWIG_AsVal_int(obj2, &val3);
34229 if (!SWIG_IsOK(ecode3)) {
34230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34231 }
34232 arg3 = static_cast< int >(val3);
34233 {
34234 PyThreadState* __tstate = wxPyBeginAllowThreads();
34235 (arg1)->WarpPointer(arg2,arg3);
34236 wxPyEndAllowThreads(__tstate);
34237 if (PyErr_Occurred()) SWIG_fail;
34238 }
34239 resultobj = SWIG_Py_Void();
34240 return resultobj;
34241 fail:
34242 return NULL;
34243 }
34244
34245
34246 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34247 PyObject *resultobj = 0;
34248 wxWindow *arg1 = (wxWindow *) 0 ;
34249 void *argp1 = 0 ;
34250 int res1 = 0 ;
34251 PyObject *swig_obj[1] ;
34252
34253 if (!args) SWIG_fail;
34254 swig_obj[0] = args;
34255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34256 if (!SWIG_IsOK(res1)) {
34257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34258 }
34259 arg1 = reinterpret_cast< wxWindow * >(argp1);
34260 {
34261 PyThreadState* __tstate = wxPyBeginAllowThreads();
34262 (arg1)->CaptureMouse();
34263 wxPyEndAllowThreads(__tstate);
34264 if (PyErr_Occurred()) SWIG_fail;
34265 }
34266 resultobj = SWIG_Py_Void();
34267 return resultobj;
34268 fail:
34269 return NULL;
34270 }
34271
34272
34273 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34274 PyObject *resultobj = 0;
34275 wxWindow *arg1 = (wxWindow *) 0 ;
34276 void *argp1 = 0 ;
34277 int res1 = 0 ;
34278 PyObject *swig_obj[1] ;
34279
34280 if (!args) SWIG_fail;
34281 swig_obj[0] = args;
34282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34283 if (!SWIG_IsOK(res1)) {
34284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34285 }
34286 arg1 = reinterpret_cast< wxWindow * >(argp1);
34287 {
34288 PyThreadState* __tstate = wxPyBeginAllowThreads();
34289 (arg1)->ReleaseMouse();
34290 wxPyEndAllowThreads(__tstate);
34291 if (PyErr_Occurred()) SWIG_fail;
34292 }
34293 resultobj = SWIG_Py_Void();
34294 return resultobj;
34295 fail:
34296 return NULL;
34297 }
34298
34299
34300 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34301 PyObject *resultobj = 0;
34302 wxWindow *result = 0 ;
34303
34304 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34305 {
34306 if (!wxPyCheckForApp()) SWIG_fail;
34307 PyThreadState* __tstate = wxPyBeginAllowThreads();
34308 result = (wxWindow *)wxWindow::GetCapture();
34309 wxPyEndAllowThreads(__tstate);
34310 if (PyErr_Occurred()) SWIG_fail;
34311 }
34312 {
34313 resultobj = wxPyMake_wxObject(result, 0);
34314 }
34315 return resultobj;
34316 fail:
34317 return NULL;
34318 }
34319
34320
34321 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34322 PyObject *resultobj = 0;
34323 wxWindow *arg1 = (wxWindow *) 0 ;
34324 bool result;
34325 void *argp1 = 0 ;
34326 int res1 = 0 ;
34327 PyObject *swig_obj[1] ;
34328
34329 if (!args) SWIG_fail;
34330 swig_obj[0] = args;
34331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34332 if (!SWIG_IsOK(res1)) {
34333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34334 }
34335 arg1 = reinterpret_cast< wxWindow * >(argp1);
34336 {
34337 PyThreadState* __tstate = wxPyBeginAllowThreads();
34338 result = (bool)((wxWindow const *)arg1)->HasCapture();
34339 wxPyEndAllowThreads(__tstate);
34340 if (PyErr_Occurred()) SWIG_fail;
34341 }
34342 {
34343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34344 }
34345 return resultobj;
34346 fail:
34347 return NULL;
34348 }
34349
34350
34351 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34352 PyObject *resultobj = 0;
34353 wxWindow *arg1 = (wxWindow *) 0 ;
34354 bool arg2 = (bool) true ;
34355 wxRect *arg3 = (wxRect *) NULL ;
34356 void *argp1 = 0 ;
34357 int res1 = 0 ;
34358 bool val2 ;
34359 int ecode2 = 0 ;
34360 void *argp3 = 0 ;
34361 int res3 = 0 ;
34362 PyObject * obj0 = 0 ;
34363 PyObject * obj1 = 0 ;
34364 PyObject * obj2 = 0 ;
34365 char * kwnames[] = {
34366 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34367 };
34368
34369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34371 if (!SWIG_IsOK(res1)) {
34372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34373 }
34374 arg1 = reinterpret_cast< wxWindow * >(argp1);
34375 if (obj1) {
34376 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34377 if (!SWIG_IsOK(ecode2)) {
34378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34379 }
34380 arg2 = static_cast< bool >(val2);
34381 }
34382 if (obj2) {
34383 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34384 if (!SWIG_IsOK(res3)) {
34385 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34386 }
34387 arg3 = reinterpret_cast< wxRect * >(argp3);
34388 }
34389 {
34390 PyThreadState* __tstate = wxPyBeginAllowThreads();
34391 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34392 wxPyEndAllowThreads(__tstate);
34393 if (PyErr_Occurred()) SWIG_fail;
34394 }
34395 resultobj = SWIG_Py_Void();
34396 return resultobj;
34397 fail:
34398 return NULL;
34399 }
34400
34401
34402 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34403 PyObject *resultobj = 0;
34404 wxWindow *arg1 = (wxWindow *) 0 ;
34405 wxRect *arg2 = 0 ;
34406 bool arg3 = (bool) true ;
34407 void *argp1 = 0 ;
34408 int res1 = 0 ;
34409 wxRect temp2 ;
34410 bool val3 ;
34411 int ecode3 = 0 ;
34412 PyObject * obj0 = 0 ;
34413 PyObject * obj1 = 0 ;
34414 PyObject * obj2 = 0 ;
34415 char * kwnames[] = {
34416 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34417 };
34418
34419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34421 if (!SWIG_IsOK(res1)) {
34422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34423 }
34424 arg1 = reinterpret_cast< wxWindow * >(argp1);
34425 {
34426 arg2 = &temp2;
34427 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34428 }
34429 if (obj2) {
34430 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34431 if (!SWIG_IsOK(ecode3)) {
34432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34433 }
34434 arg3 = static_cast< bool >(val3);
34435 }
34436 {
34437 PyThreadState* __tstate = wxPyBeginAllowThreads();
34438 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34439 wxPyEndAllowThreads(__tstate);
34440 if (PyErr_Occurred()) SWIG_fail;
34441 }
34442 resultobj = SWIG_Py_Void();
34443 return resultobj;
34444 fail:
34445 return NULL;
34446 }
34447
34448
34449 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34450 PyObject *resultobj = 0;
34451 wxWindow *arg1 = (wxWindow *) 0 ;
34452 void *argp1 = 0 ;
34453 int res1 = 0 ;
34454 PyObject *swig_obj[1] ;
34455
34456 if (!args) SWIG_fail;
34457 swig_obj[0] = args;
34458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34459 if (!SWIG_IsOK(res1)) {
34460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34461 }
34462 arg1 = reinterpret_cast< wxWindow * >(argp1);
34463 {
34464 PyThreadState* __tstate = wxPyBeginAllowThreads();
34465 (arg1)->Update();
34466 wxPyEndAllowThreads(__tstate);
34467 if (PyErr_Occurred()) SWIG_fail;
34468 }
34469 resultobj = SWIG_Py_Void();
34470 return resultobj;
34471 fail:
34472 return NULL;
34473 }
34474
34475
34476 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34477 PyObject *resultobj = 0;
34478 wxWindow *arg1 = (wxWindow *) 0 ;
34479 void *argp1 = 0 ;
34480 int res1 = 0 ;
34481 PyObject *swig_obj[1] ;
34482
34483 if (!args) SWIG_fail;
34484 swig_obj[0] = args;
34485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34486 if (!SWIG_IsOK(res1)) {
34487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34488 }
34489 arg1 = reinterpret_cast< wxWindow * >(argp1);
34490 {
34491 PyThreadState* __tstate = wxPyBeginAllowThreads();
34492 (arg1)->ClearBackground();
34493 wxPyEndAllowThreads(__tstate);
34494 if (PyErr_Occurred()) SWIG_fail;
34495 }
34496 resultobj = SWIG_Py_Void();
34497 return resultobj;
34498 fail:
34499 return NULL;
34500 }
34501
34502
34503 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34504 PyObject *resultobj = 0;
34505 wxWindow *arg1 = (wxWindow *) 0 ;
34506 void *argp1 = 0 ;
34507 int res1 = 0 ;
34508 PyObject *swig_obj[1] ;
34509
34510 if (!args) SWIG_fail;
34511 swig_obj[0] = args;
34512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34513 if (!SWIG_IsOK(res1)) {
34514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34515 }
34516 arg1 = reinterpret_cast< wxWindow * >(argp1);
34517 {
34518 PyThreadState* __tstate = wxPyBeginAllowThreads();
34519 (arg1)->Freeze();
34520 wxPyEndAllowThreads(__tstate);
34521 if (PyErr_Occurred()) SWIG_fail;
34522 }
34523 resultobj = SWIG_Py_Void();
34524 return resultobj;
34525 fail:
34526 return NULL;
34527 }
34528
34529
34530 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34531 PyObject *resultobj = 0;
34532 wxWindow *arg1 = (wxWindow *) 0 ;
34533 void *argp1 = 0 ;
34534 int res1 = 0 ;
34535 PyObject *swig_obj[1] ;
34536
34537 if (!args) SWIG_fail;
34538 swig_obj[0] = args;
34539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34540 if (!SWIG_IsOK(res1)) {
34541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34542 }
34543 arg1 = reinterpret_cast< wxWindow * >(argp1);
34544 {
34545 PyThreadState* __tstate = wxPyBeginAllowThreads();
34546 (arg1)->Thaw();
34547 wxPyEndAllowThreads(__tstate);
34548 if (PyErr_Occurred()) SWIG_fail;
34549 }
34550 resultobj = SWIG_Py_Void();
34551 return resultobj;
34552 fail:
34553 return NULL;
34554 }
34555
34556
34557 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34558 PyObject *resultobj = 0;
34559 wxWindow *arg1 = (wxWindow *) 0 ;
34560 wxDC *arg2 = 0 ;
34561 void *argp1 = 0 ;
34562 int res1 = 0 ;
34563 void *argp2 = 0 ;
34564 int res2 = 0 ;
34565 PyObject * obj0 = 0 ;
34566 PyObject * obj1 = 0 ;
34567 char * kwnames[] = {
34568 (char *) "self",(char *) "dc", NULL
34569 };
34570
34571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34573 if (!SWIG_IsOK(res1)) {
34574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34575 }
34576 arg1 = reinterpret_cast< wxWindow * >(argp1);
34577 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34578 if (!SWIG_IsOK(res2)) {
34579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34580 }
34581 if (!argp2) {
34582 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34583 }
34584 arg2 = reinterpret_cast< wxDC * >(argp2);
34585 {
34586 PyThreadState* __tstate = wxPyBeginAllowThreads();
34587 (arg1)->PrepareDC(*arg2);
34588 wxPyEndAllowThreads(__tstate);
34589 if (PyErr_Occurred()) SWIG_fail;
34590 }
34591 resultobj = SWIG_Py_Void();
34592 return resultobj;
34593 fail:
34594 return NULL;
34595 }
34596
34597
34598 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34599 PyObject *resultobj = 0;
34600 wxWindow *arg1 = (wxWindow *) 0 ;
34601 wxRegion *result = 0 ;
34602 void *argp1 = 0 ;
34603 int res1 = 0 ;
34604 PyObject *swig_obj[1] ;
34605
34606 if (!args) SWIG_fail;
34607 swig_obj[0] = args;
34608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34609 if (!SWIG_IsOK(res1)) {
34610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34611 }
34612 arg1 = reinterpret_cast< wxWindow * >(argp1);
34613 {
34614 PyThreadState* __tstate = wxPyBeginAllowThreads();
34615 {
34616 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34617 result = (wxRegion *) &_result_ref;
34618 }
34619 wxPyEndAllowThreads(__tstate);
34620 if (PyErr_Occurred()) SWIG_fail;
34621 }
34622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34623 return resultobj;
34624 fail:
34625 return NULL;
34626 }
34627
34628
34629 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34630 PyObject *resultobj = 0;
34631 wxWindow *arg1 = (wxWindow *) 0 ;
34632 wxRect result;
34633 void *argp1 = 0 ;
34634 int res1 = 0 ;
34635 PyObject *swig_obj[1] ;
34636
34637 if (!args) SWIG_fail;
34638 swig_obj[0] = args;
34639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34640 if (!SWIG_IsOK(res1)) {
34641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34642 }
34643 arg1 = reinterpret_cast< wxWindow * >(argp1);
34644 {
34645 PyThreadState* __tstate = wxPyBeginAllowThreads();
34646 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34647 wxPyEndAllowThreads(__tstate);
34648 if (PyErr_Occurred()) SWIG_fail;
34649 }
34650 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34651 return resultobj;
34652 fail:
34653 return NULL;
34654 }
34655
34656
34657 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34658 PyObject *resultobj = 0;
34659 wxWindow *arg1 = (wxWindow *) 0 ;
34660 int arg2 ;
34661 int arg3 ;
34662 int arg4 = (int) 1 ;
34663 int arg5 = (int) 1 ;
34664 bool result;
34665 void *argp1 = 0 ;
34666 int res1 = 0 ;
34667 int val2 ;
34668 int ecode2 = 0 ;
34669 int val3 ;
34670 int ecode3 = 0 ;
34671 int val4 ;
34672 int ecode4 = 0 ;
34673 int val5 ;
34674 int ecode5 = 0 ;
34675 PyObject * obj0 = 0 ;
34676 PyObject * obj1 = 0 ;
34677 PyObject * obj2 = 0 ;
34678 PyObject * obj3 = 0 ;
34679 PyObject * obj4 = 0 ;
34680 char * kwnames[] = {
34681 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34682 };
34683
34684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34686 if (!SWIG_IsOK(res1)) {
34687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34688 }
34689 arg1 = reinterpret_cast< wxWindow * >(argp1);
34690 ecode2 = SWIG_AsVal_int(obj1, &val2);
34691 if (!SWIG_IsOK(ecode2)) {
34692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34693 }
34694 arg2 = static_cast< int >(val2);
34695 ecode3 = SWIG_AsVal_int(obj2, &val3);
34696 if (!SWIG_IsOK(ecode3)) {
34697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34698 }
34699 arg3 = static_cast< int >(val3);
34700 if (obj3) {
34701 ecode4 = SWIG_AsVal_int(obj3, &val4);
34702 if (!SWIG_IsOK(ecode4)) {
34703 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34704 }
34705 arg4 = static_cast< int >(val4);
34706 }
34707 if (obj4) {
34708 ecode5 = SWIG_AsVal_int(obj4, &val5);
34709 if (!SWIG_IsOK(ecode5)) {
34710 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34711 }
34712 arg5 = static_cast< int >(val5);
34713 }
34714 {
34715 PyThreadState* __tstate = wxPyBeginAllowThreads();
34716 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34717 wxPyEndAllowThreads(__tstate);
34718 if (PyErr_Occurred()) SWIG_fail;
34719 }
34720 {
34721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34722 }
34723 return resultobj;
34724 fail:
34725 return NULL;
34726 }
34727
34728
34729 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34730 PyObject *resultobj = 0;
34731 wxWindow *arg1 = (wxWindow *) 0 ;
34732 wxPoint *arg2 = 0 ;
34733 bool result;
34734 void *argp1 = 0 ;
34735 int res1 = 0 ;
34736 wxPoint temp2 ;
34737 PyObject * obj0 = 0 ;
34738 PyObject * obj1 = 0 ;
34739 char * kwnames[] = {
34740 (char *) "self",(char *) "pt", NULL
34741 };
34742
34743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34745 if (!SWIG_IsOK(res1)) {
34746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34747 }
34748 arg1 = reinterpret_cast< wxWindow * >(argp1);
34749 {
34750 arg2 = &temp2;
34751 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34752 }
34753 {
34754 PyThreadState* __tstate = wxPyBeginAllowThreads();
34755 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34756 wxPyEndAllowThreads(__tstate);
34757 if (PyErr_Occurred()) SWIG_fail;
34758 }
34759 {
34760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34761 }
34762 return resultobj;
34763 fail:
34764 return NULL;
34765 }
34766
34767
34768 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34769 PyObject *resultobj = 0;
34770 wxWindow *arg1 = (wxWindow *) 0 ;
34771 wxRect *arg2 = 0 ;
34772 bool result;
34773 void *argp1 = 0 ;
34774 int res1 = 0 ;
34775 wxRect temp2 ;
34776 PyObject * obj0 = 0 ;
34777 PyObject * obj1 = 0 ;
34778 char * kwnames[] = {
34779 (char *) "self",(char *) "rect", NULL
34780 };
34781
34782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34784 if (!SWIG_IsOK(res1)) {
34785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34786 }
34787 arg1 = reinterpret_cast< wxWindow * >(argp1);
34788 {
34789 arg2 = &temp2;
34790 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34791 }
34792 {
34793 PyThreadState* __tstate = wxPyBeginAllowThreads();
34794 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34795 wxPyEndAllowThreads(__tstate);
34796 if (PyErr_Occurred()) SWIG_fail;
34797 }
34798 {
34799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34800 }
34801 return resultobj;
34802 fail:
34803 return NULL;
34804 }
34805
34806
34807 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34808 PyObject *resultobj = 0;
34809 wxWindow *arg1 = (wxWindow *) 0 ;
34810 SwigValueWrapper<wxVisualAttributes > result;
34811 void *argp1 = 0 ;
34812 int res1 = 0 ;
34813 PyObject *swig_obj[1] ;
34814
34815 if (!args) SWIG_fail;
34816 swig_obj[0] = args;
34817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34818 if (!SWIG_IsOK(res1)) {
34819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34820 }
34821 arg1 = reinterpret_cast< wxWindow * >(argp1);
34822 {
34823 PyThreadState* __tstate = wxPyBeginAllowThreads();
34824 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34825 wxPyEndAllowThreads(__tstate);
34826 if (PyErr_Occurred()) SWIG_fail;
34827 }
34828 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34829 return resultobj;
34830 fail:
34831 return NULL;
34832 }
34833
34834
34835 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34836 PyObject *resultobj = 0;
34837 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34838 SwigValueWrapper<wxVisualAttributes > result;
34839 int val1 ;
34840 int ecode1 = 0 ;
34841 PyObject * obj0 = 0 ;
34842 char * kwnames[] = {
34843 (char *) "variant", NULL
34844 };
34845
34846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34847 if (obj0) {
34848 ecode1 = SWIG_AsVal_int(obj0, &val1);
34849 if (!SWIG_IsOK(ecode1)) {
34850 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34851 }
34852 arg1 = static_cast< wxWindowVariant >(val1);
34853 }
34854 {
34855 if (!wxPyCheckForApp()) SWIG_fail;
34856 PyThreadState* __tstate = wxPyBeginAllowThreads();
34857 result = wxWindow::GetClassDefaultAttributes(arg1);
34858 wxPyEndAllowThreads(__tstate);
34859 if (PyErr_Occurred()) SWIG_fail;
34860 }
34861 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34862 return resultobj;
34863 fail:
34864 return NULL;
34865 }
34866
34867
34868 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34869 PyObject *resultobj = 0;
34870 wxWindow *arg1 = (wxWindow *) 0 ;
34871 wxColour *arg2 = 0 ;
34872 bool result;
34873 void *argp1 = 0 ;
34874 int res1 = 0 ;
34875 wxColour temp2 ;
34876 PyObject * obj0 = 0 ;
34877 PyObject * obj1 = 0 ;
34878 char * kwnames[] = {
34879 (char *) "self",(char *) "colour", NULL
34880 };
34881
34882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34884 if (!SWIG_IsOK(res1)) {
34885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34886 }
34887 arg1 = reinterpret_cast< wxWindow * >(argp1);
34888 {
34889 arg2 = &temp2;
34890 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34891 }
34892 {
34893 PyThreadState* __tstate = wxPyBeginAllowThreads();
34894 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34895 wxPyEndAllowThreads(__tstate);
34896 if (PyErr_Occurred()) SWIG_fail;
34897 }
34898 {
34899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34900 }
34901 return resultobj;
34902 fail:
34903 return NULL;
34904 }
34905
34906
34907 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34908 PyObject *resultobj = 0;
34909 wxWindow *arg1 = (wxWindow *) 0 ;
34910 wxColour *arg2 = 0 ;
34911 void *argp1 = 0 ;
34912 int res1 = 0 ;
34913 wxColour temp2 ;
34914 PyObject * obj0 = 0 ;
34915 PyObject * obj1 = 0 ;
34916 char * kwnames[] = {
34917 (char *) "self",(char *) "colour", NULL
34918 };
34919
34920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34922 if (!SWIG_IsOK(res1)) {
34923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34924 }
34925 arg1 = reinterpret_cast< wxWindow * >(argp1);
34926 {
34927 arg2 = &temp2;
34928 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34929 }
34930 {
34931 PyThreadState* __tstate = wxPyBeginAllowThreads();
34932 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34933 wxPyEndAllowThreads(__tstate);
34934 if (PyErr_Occurred()) SWIG_fail;
34935 }
34936 resultobj = SWIG_Py_Void();
34937 return resultobj;
34938 fail:
34939 return NULL;
34940 }
34941
34942
34943 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34944 PyObject *resultobj = 0;
34945 wxWindow *arg1 = (wxWindow *) 0 ;
34946 wxColour *arg2 = 0 ;
34947 bool result;
34948 void *argp1 = 0 ;
34949 int res1 = 0 ;
34950 wxColour temp2 ;
34951 PyObject * obj0 = 0 ;
34952 PyObject * obj1 = 0 ;
34953 char * kwnames[] = {
34954 (char *) "self",(char *) "colour", NULL
34955 };
34956
34957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34959 if (!SWIG_IsOK(res1)) {
34960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34961 }
34962 arg1 = reinterpret_cast< wxWindow * >(argp1);
34963 {
34964 arg2 = &temp2;
34965 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34966 }
34967 {
34968 PyThreadState* __tstate = wxPyBeginAllowThreads();
34969 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34970 wxPyEndAllowThreads(__tstate);
34971 if (PyErr_Occurred()) SWIG_fail;
34972 }
34973 {
34974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34975 }
34976 return resultobj;
34977 fail:
34978 return NULL;
34979 }
34980
34981
34982 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34983 PyObject *resultobj = 0;
34984 wxWindow *arg1 = (wxWindow *) 0 ;
34985 wxColour *arg2 = 0 ;
34986 void *argp1 = 0 ;
34987 int res1 = 0 ;
34988 wxColour temp2 ;
34989 PyObject * obj0 = 0 ;
34990 PyObject * obj1 = 0 ;
34991 char * kwnames[] = {
34992 (char *) "self",(char *) "colour", NULL
34993 };
34994
34995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34997 if (!SWIG_IsOK(res1)) {
34998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34999 }
35000 arg1 = reinterpret_cast< wxWindow * >(argp1);
35001 {
35002 arg2 = &temp2;
35003 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35004 }
35005 {
35006 PyThreadState* __tstate = wxPyBeginAllowThreads();
35007 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35008 wxPyEndAllowThreads(__tstate);
35009 if (PyErr_Occurred()) SWIG_fail;
35010 }
35011 resultobj = SWIG_Py_Void();
35012 return resultobj;
35013 fail:
35014 return NULL;
35015 }
35016
35017
35018 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35019 PyObject *resultobj = 0;
35020 wxWindow *arg1 = (wxWindow *) 0 ;
35021 wxColour result;
35022 void *argp1 = 0 ;
35023 int res1 = 0 ;
35024 PyObject *swig_obj[1] ;
35025
35026 if (!args) SWIG_fail;
35027 swig_obj[0] = args;
35028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35029 if (!SWIG_IsOK(res1)) {
35030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35031 }
35032 arg1 = reinterpret_cast< wxWindow * >(argp1);
35033 {
35034 PyThreadState* __tstate = wxPyBeginAllowThreads();
35035 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35036 wxPyEndAllowThreads(__tstate);
35037 if (PyErr_Occurred()) SWIG_fail;
35038 }
35039 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35040 return resultobj;
35041 fail:
35042 return NULL;
35043 }
35044
35045
35046 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35047 PyObject *resultobj = 0;
35048 wxWindow *arg1 = (wxWindow *) 0 ;
35049 wxColour result;
35050 void *argp1 = 0 ;
35051 int res1 = 0 ;
35052 PyObject *swig_obj[1] ;
35053
35054 if (!args) SWIG_fail;
35055 swig_obj[0] = args;
35056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35057 if (!SWIG_IsOK(res1)) {
35058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35059 }
35060 arg1 = reinterpret_cast< wxWindow * >(argp1);
35061 {
35062 PyThreadState* __tstate = wxPyBeginAllowThreads();
35063 result = ((wxWindow const *)arg1)->GetForegroundColour();
35064 wxPyEndAllowThreads(__tstate);
35065 if (PyErr_Occurred()) SWIG_fail;
35066 }
35067 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35068 return resultobj;
35069 fail:
35070 return NULL;
35071 }
35072
35073
35074 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35075 PyObject *resultobj = 0;
35076 wxWindow *arg1 = (wxWindow *) 0 ;
35077 bool result;
35078 void *argp1 = 0 ;
35079 int res1 = 0 ;
35080 PyObject *swig_obj[1] ;
35081
35082 if (!args) SWIG_fail;
35083 swig_obj[0] = args;
35084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35085 if (!SWIG_IsOK(res1)) {
35086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35087 }
35088 arg1 = reinterpret_cast< wxWindow * >(argp1);
35089 {
35090 PyThreadState* __tstate = wxPyBeginAllowThreads();
35091 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35092 wxPyEndAllowThreads(__tstate);
35093 if (PyErr_Occurred()) SWIG_fail;
35094 }
35095 {
35096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35097 }
35098 return resultobj;
35099 fail:
35100 return NULL;
35101 }
35102
35103
35104 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35105 PyObject *resultobj = 0;
35106 wxWindow *arg1 = (wxWindow *) 0 ;
35107 bool result;
35108 void *argp1 = 0 ;
35109 int res1 = 0 ;
35110 PyObject *swig_obj[1] ;
35111
35112 if (!args) SWIG_fail;
35113 swig_obj[0] = args;
35114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35115 if (!SWIG_IsOK(res1)) {
35116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35117 }
35118 arg1 = reinterpret_cast< wxWindow * >(argp1);
35119 {
35120 PyThreadState* __tstate = wxPyBeginAllowThreads();
35121 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35122 wxPyEndAllowThreads(__tstate);
35123 if (PyErr_Occurred()) SWIG_fail;
35124 }
35125 {
35126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35127 }
35128 return resultobj;
35129 fail:
35130 return NULL;
35131 }
35132
35133
35134 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35135 PyObject *resultobj = 0;
35136 wxWindow *arg1 = (wxWindow *) 0 ;
35137 wxBackgroundStyle arg2 ;
35138 bool result;
35139 void *argp1 = 0 ;
35140 int res1 = 0 ;
35141 int val2 ;
35142 int ecode2 = 0 ;
35143 PyObject * obj0 = 0 ;
35144 PyObject * obj1 = 0 ;
35145 char * kwnames[] = {
35146 (char *) "self",(char *) "style", NULL
35147 };
35148
35149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35151 if (!SWIG_IsOK(res1)) {
35152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35153 }
35154 arg1 = reinterpret_cast< wxWindow * >(argp1);
35155 ecode2 = SWIG_AsVal_int(obj1, &val2);
35156 if (!SWIG_IsOK(ecode2)) {
35157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35158 }
35159 arg2 = static_cast< wxBackgroundStyle >(val2);
35160 {
35161 PyThreadState* __tstate = wxPyBeginAllowThreads();
35162 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35163 wxPyEndAllowThreads(__tstate);
35164 if (PyErr_Occurred()) SWIG_fail;
35165 }
35166 {
35167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35168 }
35169 return resultobj;
35170 fail:
35171 return NULL;
35172 }
35173
35174
35175 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35176 PyObject *resultobj = 0;
35177 wxWindow *arg1 = (wxWindow *) 0 ;
35178 wxBackgroundStyle result;
35179 void *argp1 = 0 ;
35180 int res1 = 0 ;
35181 PyObject *swig_obj[1] ;
35182
35183 if (!args) SWIG_fail;
35184 swig_obj[0] = args;
35185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35186 if (!SWIG_IsOK(res1)) {
35187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35188 }
35189 arg1 = reinterpret_cast< wxWindow * >(argp1);
35190 {
35191 PyThreadState* __tstate = wxPyBeginAllowThreads();
35192 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35193 wxPyEndAllowThreads(__tstate);
35194 if (PyErr_Occurred()) SWIG_fail;
35195 }
35196 resultobj = SWIG_From_int(static_cast< int >(result));
35197 return resultobj;
35198 fail:
35199 return NULL;
35200 }
35201
35202
35203 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35204 PyObject *resultobj = 0;
35205 wxWindow *arg1 = (wxWindow *) 0 ;
35206 bool result;
35207 void *argp1 = 0 ;
35208 int res1 = 0 ;
35209 PyObject *swig_obj[1] ;
35210
35211 if (!args) SWIG_fail;
35212 swig_obj[0] = args;
35213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35214 if (!SWIG_IsOK(res1)) {
35215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35216 }
35217 arg1 = reinterpret_cast< wxWindow * >(argp1);
35218 {
35219 PyThreadState* __tstate = wxPyBeginAllowThreads();
35220 result = (bool)(arg1)->HasTransparentBackground();
35221 wxPyEndAllowThreads(__tstate);
35222 if (PyErr_Occurred()) SWIG_fail;
35223 }
35224 {
35225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35226 }
35227 return resultobj;
35228 fail:
35229 return NULL;
35230 }
35231
35232
35233 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35234 PyObject *resultobj = 0;
35235 wxWindow *arg1 = (wxWindow *) 0 ;
35236 wxCursor *arg2 = 0 ;
35237 bool result;
35238 void *argp1 = 0 ;
35239 int res1 = 0 ;
35240 void *argp2 = 0 ;
35241 int res2 = 0 ;
35242 PyObject * obj0 = 0 ;
35243 PyObject * obj1 = 0 ;
35244 char * kwnames[] = {
35245 (char *) "self",(char *) "cursor", NULL
35246 };
35247
35248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35250 if (!SWIG_IsOK(res1)) {
35251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35252 }
35253 arg1 = reinterpret_cast< wxWindow * >(argp1);
35254 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35255 if (!SWIG_IsOK(res2)) {
35256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35257 }
35258 if (!argp2) {
35259 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35260 }
35261 arg2 = reinterpret_cast< wxCursor * >(argp2);
35262 {
35263 PyThreadState* __tstate = wxPyBeginAllowThreads();
35264 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35265 wxPyEndAllowThreads(__tstate);
35266 if (PyErr_Occurred()) SWIG_fail;
35267 }
35268 {
35269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35270 }
35271 return resultobj;
35272 fail:
35273 return NULL;
35274 }
35275
35276
35277 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35278 PyObject *resultobj = 0;
35279 wxWindow *arg1 = (wxWindow *) 0 ;
35280 wxCursor result;
35281 void *argp1 = 0 ;
35282 int res1 = 0 ;
35283 PyObject *swig_obj[1] ;
35284
35285 if (!args) SWIG_fail;
35286 swig_obj[0] = args;
35287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35288 if (!SWIG_IsOK(res1)) {
35289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35290 }
35291 arg1 = reinterpret_cast< wxWindow * >(argp1);
35292 {
35293 PyThreadState* __tstate = wxPyBeginAllowThreads();
35294 result = (arg1)->GetCursor();
35295 wxPyEndAllowThreads(__tstate);
35296 if (PyErr_Occurred()) SWIG_fail;
35297 }
35298 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35299 return resultobj;
35300 fail:
35301 return NULL;
35302 }
35303
35304
35305 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35306 PyObject *resultobj = 0;
35307 wxWindow *arg1 = (wxWindow *) 0 ;
35308 wxFont *arg2 = 0 ;
35309 bool result;
35310 void *argp1 = 0 ;
35311 int res1 = 0 ;
35312 void *argp2 = 0 ;
35313 int res2 = 0 ;
35314 PyObject * obj0 = 0 ;
35315 PyObject * obj1 = 0 ;
35316 char * kwnames[] = {
35317 (char *) "self",(char *) "font", NULL
35318 };
35319
35320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35322 if (!SWIG_IsOK(res1)) {
35323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35324 }
35325 arg1 = reinterpret_cast< wxWindow * >(argp1);
35326 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35327 if (!SWIG_IsOK(res2)) {
35328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35329 }
35330 if (!argp2) {
35331 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35332 }
35333 arg2 = reinterpret_cast< wxFont * >(argp2);
35334 {
35335 PyThreadState* __tstate = wxPyBeginAllowThreads();
35336 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35337 wxPyEndAllowThreads(__tstate);
35338 if (PyErr_Occurred()) SWIG_fail;
35339 }
35340 {
35341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35342 }
35343 return resultobj;
35344 fail:
35345 return NULL;
35346 }
35347
35348
35349 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35350 PyObject *resultobj = 0;
35351 wxWindow *arg1 = (wxWindow *) 0 ;
35352 wxFont *arg2 = 0 ;
35353 void *argp1 = 0 ;
35354 int res1 = 0 ;
35355 void *argp2 = 0 ;
35356 int res2 = 0 ;
35357 PyObject * obj0 = 0 ;
35358 PyObject * obj1 = 0 ;
35359 char * kwnames[] = {
35360 (char *) "self",(char *) "font", NULL
35361 };
35362
35363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35365 if (!SWIG_IsOK(res1)) {
35366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35367 }
35368 arg1 = reinterpret_cast< wxWindow * >(argp1);
35369 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35370 if (!SWIG_IsOK(res2)) {
35371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35372 }
35373 if (!argp2) {
35374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35375 }
35376 arg2 = reinterpret_cast< wxFont * >(argp2);
35377 {
35378 PyThreadState* __tstate = wxPyBeginAllowThreads();
35379 (arg1)->SetOwnFont((wxFont const &)*arg2);
35380 wxPyEndAllowThreads(__tstate);
35381 if (PyErr_Occurred()) SWIG_fail;
35382 }
35383 resultobj = SWIG_Py_Void();
35384 return resultobj;
35385 fail:
35386 return NULL;
35387 }
35388
35389
35390 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35391 PyObject *resultobj = 0;
35392 wxWindow *arg1 = (wxWindow *) 0 ;
35393 wxFont result;
35394 void *argp1 = 0 ;
35395 int res1 = 0 ;
35396 PyObject *swig_obj[1] ;
35397
35398 if (!args) SWIG_fail;
35399 swig_obj[0] = args;
35400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35401 if (!SWIG_IsOK(res1)) {
35402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35403 }
35404 arg1 = reinterpret_cast< wxWindow * >(argp1);
35405 {
35406 PyThreadState* __tstate = wxPyBeginAllowThreads();
35407 result = (arg1)->GetFont();
35408 wxPyEndAllowThreads(__tstate);
35409 if (PyErr_Occurred()) SWIG_fail;
35410 }
35411 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35412 return resultobj;
35413 fail:
35414 return NULL;
35415 }
35416
35417
35418 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35419 PyObject *resultobj = 0;
35420 wxWindow *arg1 = (wxWindow *) 0 ;
35421 wxCaret *arg2 = (wxCaret *) 0 ;
35422 void *argp1 = 0 ;
35423 int res1 = 0 ;
35424 int res2 = 0 ;
35425 PyObject * obj0 = 0 ;
35426 PyObject * obj1 = 0 ;
35427 char * kwnames[] = {
35428 (char *) "self",(char *) "caret", NULL
35429 };
35430
35431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35433 if (!SWIG_IsOK(res1)) {
35434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35435 }
35436 arg1 = reinterpret_cast< wxWindow * >(argp1);
35437 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35438 if (!SWIG_IsOK(res2)) {
35439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35440 }
35441 {
35442 PyThreadState* __tstate = wxPyBeginAllowThreads();
35443 (arg1)->SetCaret(arg2);
35444 wxPyEndAllowThreads(__tstate);
35445 if (PyErr_Occurred()) SWIG_fail;
35446 }
35447 resultobj = SWIG_Py_Void();
35448 return resultobj;
35449 fail:
35450 return NULL;
35451 }
35452
35453
35454 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35455 PyObject *resultobj = 0;
35456 wxWindow *arg1 = (wxWindow *) 0 ;
35457 wxCaret *result = 0 ;
35458 void *argp1 = 0 ;
35459 int res1 = 0 ;
35460 PyObject *swig_obj[1] ;
35461
35462 if (!args) SWIG_fail;
35463 swig_obj[0] = args;
35464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35465 if (!SWIG_IsOK(res1)) {
35466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35467 }
35468 arg1 = reinterpret_cast< wxWindow * >(argp1);
35469 {
35470 PyThreadState* __tstate = wxPyBeginAllowThreads();
35471 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35472 wxPyEndAllowThreads(__tstate);
35473 if (PyErr_Occurred()) SWIG_fail;
35474 }
35475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35476 return resultobj;
35477 fail:
35478 return NULL;
35479 }
35480
35481
35482 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35483 PyObject *resultobj = 0;
35484 wxWindow *arg1 = (wxWindow *) 0 ;
35485 int result;
35486 void *argp1 = 0 ;
35487 int res1 = 0 ;
35488 PyObject *swig_obj[1] ;
35489
35490 if (!args) SWIG_fail;
35491 swig_obj[0] = args;
35492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35493 if (!SWIG_IsOK(res1)) {
35494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35495 }
35496 arg1 = reinterpret_cast< wxWindow * >(argp1);
35497 {
35498 PyThreadState* __tstate = wxPyBeginAllowThreads();
35499 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35500 wxPyEndAllowThreads(__tstate);
35501 if (PyErr_Occurred()) SWIG_fail;
35502 }
35503 resultobj = SWIG_From_int(static_cast< int >(result));
35504 return resultobj;
35505 fail:
35506 return NULL;
35507 }
35508
35509
35510 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35511 PyObject *resultobj = 0;
35512 wxWindow *arg1 = (wxWindow *) 0 ;
35513 int result;
35514 void *argp1 = 0 ;
35515 int res1 = 0 ;
35516 PyObject *swig_obj[1] ;
35517
35518 if (!args) SWIG_fail;
35519 swig_obj[0] = args;
35520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35521 if (!SWIG_IsOK(res1)) {
35522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35523 }
35524 arg1 = reinterpret_cast< wxWindow * >(argp1);
35525 {
35526 PyThreadState* __tstate = wxPyBeginAllowThreads();
35527 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35528 wxPyEndAllowThreads(__tstate);
35529 if (PyErr_Occurred()) SWIG_fail;
35530 }
35531 resultobj = SWIG_From_int(static_cast< int >(result));
35532 return resultobj;
35533 fail:
35534 return NULL;
35535 }
35536
35537
35538 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35539 PyObject *resultobj = 0;
35540 wxWindow *arg1 = (wxWindow *) 0 ;
35541 wxString *arg2 = 0 ;
35542 int *arg3 = (int *) 0 ;
35543 int *arg4 = (int *) 0 ;
35544 void *argp1 = 0 ;
35545 int res1 = 0 ;
35546 bool temp2 = false ;
35547 int temp3 ;
35548 int res3 = SWIG_TMPOBJ ;
35549 int temp4 ;
35550 int res4 = SWIG_TMPOBJ ;
35551 PyObject * obj0 = 0 ;
35552 PyObject * obj1 = 0 ;
35553 char * kwnames[] = {
35554 (char *) "self",(char *) "string", NULL
35555 };
35556
35557 arg3 = &temp3;
35558 arg4 = &temp4;
35559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35561 if (!SWIG_IsOK(res1)) {
35562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35563 }
35564 arg1 = reinterpret_cast< wxWindow * >(argp1);
35565 {
35566 arg2 = wxString_in_helper(obj1);
35567 if (arg2 == NULL) SWIG_fail;
35568 temp2 = true;
35569 }
35570 {
35571 PyThreadState* __tstate = wxPyBeginAllowThreads();
35572 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35573 wxPyEndAllowThreads(__tstate);
35574 if (PyErr_Occurred()) SWIG_fail;
35575 }
35576 resultobj = SWIG_Py_Void();
35577 if (SWIG_IsTmpObj(res3)) {
35578 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35579 } else {
35580 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35581 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35582 }
35583 if (SWIG_IsTmpObj(res4)) {
35584 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35585 } else {
35586 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35587 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35588 }
35589 {
35590 if (temp2)
35591 delete arg2;
35592 }
35593 return resultobj;
35594 fail:
35595 {
35596 if (temp2)
35597 delete arg2;
35598 }
35599 return NULL;
35600 }
35601
35602
35603 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35604 PyObject *resultobj = 0;
35605 wxWindow *arg1 = (wxWindow *) 0 ;
35606 wxString *arg2 = 0 ;
35607 int *arg3 = (int *) 0 ;
35608 int *arg4 = (int *) 0 ;
35609 int *arg5 = (int *) 0 ;
35610 int *arg6 = (int *) 0 ;
35611 wxFont *arg7 = (wxFont *) NULL ;
35612 void *argp1 = 0 ;
35613 int res1 = 0 ;
35614 bool temp2 = false ;
35615 int temp3 ;
35616 int res3 = SWIG_TMPOBJ ;
35617 int temp4 ;
35618 int res4 = SWIG_TMPOBJ ;
35619 int temp5 ;
35620 int res5 = SWIG_TMPOBJ ;
35621 int temp6 ;
35622 int res6 = SWIG_TMPOBJ ;
35623 void *argp7 = 0 ;
35624 int res7 = 0 ;
35625 PyObject * obj0 = 0 ;
35626 PyObject * obj1 = 0 ;
35627 PyObject * obj2 = 0 ;
35628 char * kwnames[] = {
35629 (char *) "self",(char *) "string",(char *) "font", NULL
35630 };
35631
35632 arg3 = &temp3;
35633 arg4 = &temp4;
35634 arg5 = &temp5;
35635 arg6 = &temp6;
35636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35638 if (!SWIG_IsOK(res1)) {
35639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35640 }
35641 arg1 = reinterpret_cast< wxWindow * >(argp1);
35642 {
35643 arg2 = wxString_in_helper(obj1);
35644 if (arg2 == NULL) SWIG_fail;
35645 temp2 = true;
35646 }
35647 if (obj2) {
35648 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35649 if (!SWIG_IsOK(res7)) {
35650 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35651 }
35652 arg7 = reinterpret_cast< wxFont * >(argp7);
35653 }
35654 {
35655 PyThreadState* __tstate = wxPyBeginAllowThreads();
35656 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35657 wxPyEndAllowThreads(__tstate);
35658 if (PyErr_Occurred()) SWIG_fail;
35659 }
35660 resultobj = SWIG_Py_Void();
35661 if (SWIG_IsTmpObj(res3)) {
35662 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35663 } else {
35664 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35665 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35666 }
35667 if (SWIG_IsTmpObj(res4)) {
35668 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35669 } else {
35670 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35671 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35672 }
35673 if (SWIG_IsTmpObj(res5)) {
35674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35675 } else {
35676 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35677 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35678 }
35679 if (SWIG_IsTmpObj(res6)) {
35680 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35681 } else {
35682 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35684 }
35685 {
35686 if (temp2)
35687 delete arg2;
35688 }
35689 return resultobj;
35690 fail:
35691 {
35692 if (temp2)
35693 delete arg2;
35694 }
35695 return NULL;
35696 }
35697
35698
35699 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35700 PyObject *resultobj = 0;
35701 wxWindow *arg1 = (wxWindow *) 0 ;
35702 int *arg2 = (int *) 0 ;
35703 int *arg3 = (int *) 0 ;
35704 void *argp1 = 0 ;
35705 int res1 = 0 ;
35706 int temp2 ;
35707 int res2 = 0 ;
35708 int temp3 ;
35709 int res3 = 0 ;
35710 PyObject * obj0 = 0 ;
35711 PyObject * obj1 = 0 ;
35712 PyObject * obj2 = 0 ;
35713 char * kwnames[] = {
35714 (char *) "self",(char *) "x",(char *) "y", NULL
35715 };
35716
35717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35719 if (!SWIG_IsOK(res1)) {
35720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35721 }
35722 arg1 = reinterpret_cast< wxWindow * >(argp1);
35723 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35724 int val;
35725 int ecode = SWIG_AsVal_int(obj1, &val);
35726 if (!SWIG_IsOK(ecode)) {
35727 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35728 }
35729 temp2 = static_cast< int >(val);
35730 arg2 = &temp2;
35731 res2 = SWIG_AddTmpMask(ecode);
35732 }
35733 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35734 int val;
35735 int ecode = SWIG_AsVal_int(obj2, &val);
35736 if (!SWIG_IsOK(ecode)) {
35737 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35738 }
35739 temp3 = static_cast< int >(val);
35740 arg3 = &temp3;
35741 res3 = SWIG_AddTmpMask(ecode);
35742 }
35743 {
35744 PyThreadState* __tstate = wxPyBeginAllowThreads();
35745 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35746 wxPyEndAllowThreads(__tstate);
35747 if (PyErr_Occurred()) SWIG_fail;
35748 }
35749 resultobj = SWIG_Py_Void();
35750 if (SWIG_IsTmpObj(res2)) {
35751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35752 } else {
35753 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35755 }
35756 if (SWIG_IsTmpObj(res3)) {
35757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35758 } else {
35759 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35761 }
35762 return resultobj;
35763 fail:
35764 return NULL;
35765 }
35766
35767
35768 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35769 PyObject *resultobj = 0;
35770 wxWindow *arg1 = (wxWindow *) 0 ;
35771 int *arg2 = (int *) 0 ;
35772 int *arg3 = (int *) 0 ;
35773 void *argp1 = 0 ;
35774 int res1 = 0 ;
35775 int temp2 ;
35776 int res2 = 0 ;
35777 int temp3 ;
35778 int res3 = 0 ;
35779 PyObject * obj0 = 0 ;
35780 PyObject * obj1 = 0 ;
35781 PyObject * obj2 = 0 ;
35782 char * kwnames[] = {
35783 (char *) "self",(char *) "x",(char *) "y", NULL
35784 };
35785
35786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35788 if (!SWIG_IsOK(res1)) {
35789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35790 }
35791 arg1 = reinterpret_cast< wxWindow * >(argp1);
35792 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35793 int val;
35794 int ecode = SWIG_AsVal_int(obj1, &val);
35795 if (!SWIG_IsOK(ecode)) {
35796 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35797 }
35798 temp2 = static_cast< int >(val);
35799 arg2 = &temp2;
35800 res2 = SWIG_AddTmpMask(ecode);
35801 }
35802 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35803 int val;
35804 int ecode = SWIG_AsVal_int(obj2, &val);
35805 if (!SWIG_IsOK(ecode)) {
35806 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35807 }
35808 temp3 = static_cast< int >(val);
35809 arg3 = &temp3;
35810 res3 = SWIG_AddTmpMask(ecode);
35811 }
35812 {
35813 PyThreadState* __tstate = wxPyBeginAllowThreads();
35814 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35815 wxPyEndAllowThreads(__tstate);
35816 if (PyErr_Occurred()) SWIG_fail;
35817 }
35818 resultobj = SWIG_Py_Void();
35819 if (SWIG_IsTmpObj(res2)) {
35820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35821 } else {
35822 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35824 }
35825 if (SWIG_IsTmpObj(res3)) {
35826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35827 } else {
35828 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35829 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35830 }
35831 return resultobj;
35832 fail:
35833 return NULL;
35834 }
35835
35836
35837 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35838 PyObject *resultobj = 0;
35839 wxWindow *arg1 = (wxWindow *) 0 ;
35840 wxPoint *arg2 = 0 ;
35841 wxPoint result;
35842 void *argp1 = 0 ;
35843 int res1 = 0 ;
35844 wxPoint temp2 ;
35845 PyObject * obj0 = 0 ;
35846 PyObject * obj1 = 0 ;
35847 char * kwnames[] = {
35848 (char *) "self",(char *) "pt", NULL
35849 };
35850
35851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35853 if (!SWIG_IsOK(res1)) {
35854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35855 }
35856 arg1 = reinterpret_cast< wxWindow * >(argp1);
35857 {
35858 arg2 = &temp2;
35859 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35860 }
35861 {
35862 PyThreadState* __tstate = wxPyBeginAllowThreads();
35863 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35864 wxPyEndAllowThreads(__tstate);
35865 if (PyErr_Occurred()) SWIG_fail;
35866 }
35867 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35868 return resultobj;
35869 fail:
35870 return NULL;
35871 }
35872
35873
35874 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35875 PyObject *resultobj = 0;
35876 wxWindow *arg1 = (wxWindow *) 0 ;
35877 wxPoint *arg2 = 0 ;
35878 wxPoint result;
35879 void *argp1 = 0 ;
35880 int res1 = 0 ;
35881 wxPoint temp2 ;
35882 PyObject * obj0 = 0 ;
35883 PyObject * obj1 = 0 ;
35884 char * kwnames[] = {
35885 (char *) "self",(char *) "pt", NULL
35886 };
35887
35888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35890 if (!SWIG_IsOK(res1)) {
35891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35892 }
35893 arg1 = reinterpret_cast< wxWindow * >(argp1);
35894 {
35895 arg2 = &temp2;
35896 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35897 }
35898 {
35899 PyThreadState* __tstate = wxPyBeginAllowThreads();
35900 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35901 wxPyEndAllowThreads(__tstate);
35902 if (PyErr_Occurred()) SWIG_fail;
35903 }
35904 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35905 return resultobj;
35906 fail:
35907 return NULL;
35908 }
35909
35910
35911 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35912 PyObject *resultobj = 0;
35913 wxWindow *arg1 = (wxWindow *) 0 ;
35914 int arg2 ;
35915 int arg3 ;
35916 wxHitTest result;
35917 void *argp1 = 0 ;
35918 int res1 = 0 ;
35919 int val2 ;
35920 int ecode2 = 0 ;
35921 int val3 ;
35922 int ecode3 = 0 ;
35923 PyObject * obj0 = 0 ;
35924 PyObject * obj1 = 0 ;
35925 PyObject * obj2 = 0 ;
35926 char * kwnames[] = {
35927 (char *) "self",(char *) "x",(char *) "y", NULL
35928 };
35929
35930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35932 if (!SWIG_IsOK(res1)) {
35933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35934 }
35935 arg1 = reinterpret_cast< wxWindow * >(argp1);
35936 ecode2 = SWIG_AsVal_int(obj1, &val2);
35937 if (!SWIG_IsOK(ecode2)) {
35938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35939 }
35940 arg2 = static_cast< int >(val2);
35941 ecode3 = SWIG_AsVal_int(obj2, &val3);
35942 if (!SWIG_IsOK(ecode3)) {
35943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35944 }
35945 arg3 = static_cast< int >(val3);
35946 {
35947 PyThreadState* __tstate = wxPyBeginAllowThreads();
35948 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35949 wxPyEndAllowThreads(__tstate);
35950 if (PyErr_Occurred()) SWIG_fail;
35951 }
35952 resultobj = SWIG_From_int(static_cast< int >(result));
35953 return resultobj;
35954 fail:
35955 return NULL;
35956 }
35957
35958
35959 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35960 PyObject *resultobj = 0;
35961 wxWindow *arg1 = (wxWindow *) 0 ;
35962 wxPoint *arg2 = 0 ;
35963 wxHitTest result;
35964 void *argp1 = 0 ;
35965 int res1 = 0 ;
35966 wxPoint temp2 ;
35967 PyObject * obj0 = 0 ;
35968 PyObject * obj1 = 0 ;
35969 char * kwnames[] = {
35970 (char *) "self",(char *) "pt", NULL
35971 };
35972
35973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35975 if (!SWIG_IsOK(res1)) {
35976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35977 }
35978 arg1 = reinterpret_cast< wxWindow * >(argp1);
35979 {
35980 arg2 = &temp2;
35981 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35982 }
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35986 wxPyEndAllowThreads(__tstate);
35987 if (PyErr_Occurred()) SWIG_fail;
35988 }
35989 resultobj = SWIG_From_int(static_cast< int >(result));
35990 return resultobj;
35991 fail:
35992 return NULL;
35993 }
35994
35995
35996 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35997 PyObject *resultobj = 0;
35998 wxWindow *arg1 = (wxWindow *) 0 ;
35999 long arg2 ;
36000 wxBorder result;
36001 void *argp1 = 0 ;
36002 int res1 = 0 ;
36003 long val2 ;
36004 int ecode2 = 0 ;
36005
36006 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36008 if (!SWIG_IsOK(res1)) {
36009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36010 }
36011 arg1 = reinterpret_cast< wxWindow * >(argp1);
36012 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36013 if (!SWIG_IsOK(ecode2)) {
36014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36015 }
36016 arg2 = static_cast< long >(val2);
36017 {
36018 PyThreadState* __tstate = wxPyBeginAllowThreads();
36019 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36020 wxPyEndAllowThreads(__tstate);
36021 if (PyErr_Occurred()) SWIG_fail;
36022 }
36023 resultobj = SWIG_From_int(static_cast< int >(result));
36024 return resultobj;
36025 fail:
36026 return NULL;
36027 }
36028
36029
36030 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36031 PyObject *resultobj = 0;
36032 wxWindow *arg1 = (wxWindow *) 0 ;
36033 wxBorder result;
36034 void *argp1 = 0 ;
36035 int res1 = 0 ;
36036
36037 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36039 if (!SWIG_IsOK(res1)) {
36040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36041 }
36042 arg1 = reinterpret_cast< wxWindow * >(argp1);
36043 {
36044 PyThreadState* __tstate = wxPyBeginAllowThreads();
36045 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36046 wxPyEndAllowThreads(__tstate);
36047 if (PyErr_Occurred()) SWIG_fail;
36048 }
36049 resultobj = SWIG_From_int(static_cast< int >(result));
36050 return resultobj;
36051 fail:
36052 return NULL;
36053 }
36054
36055
36056 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36057 int argc;
36058 PyObject *argv[3];
36059
36060 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36061 --argc;
36062 if (argc == 1) {
36063 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36064 }
36065 if (argc == 2) {
36066 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36067 }
36068
36069 fail:
36070 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36071 return NULL;
36072 }
36073
36074
36075 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36076 PyObject *resultobj = 0;
36077 wxWindow *arg1 = (wxWindow *) 0 ;
36078 long arg2 = (long) wxUPDATE_UI_NONE ;
36079 void *argp1 = 0 ;
36080 int res1 = 0 ;
36081 long val2 ;
36082 int ecode2 = 0 ;
36083 PyObject * obj0 = 0 ;
36084 PyObject * obj1 = 0 ;
36085 char * kwnames[] = {
36086 (char *) "self",(char *) "flags", NULL
36087 };
36088
36089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36091 if (!SWIG_IsOK(res1)) {
36092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36093 }
36094 arg1 = reinterpret_cast< wxWindow * >(argp1);
36095 if (obj1) {
36096 ecode2 = SWIG_AsVal_long(obj1, &val2);
36097 if (!SWIG_IsOK(ecode2)) {
36098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36099 }
36100 arg2 = static_cast< long >(val2);
36101 }
36102 {
36103 PyThreadState* __tstate = wxPyBeginAllowThreads();
36104 (arg1)->UpdateWindowUI(arg2);
36105 wxPyEndAllowThreads(__tstate);
36106 if (PyErr_Occurred()) SWIG_fail;
36107 }
36108 resultobj = SWIG_Py_Void();
36109 return resultobj;
36110 fail:
36111 return NULL;
36112 }
36113
36114
36115 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36116 PyObject *resultobj = 0;
36117 wxWindow *arg1 = (wxWindow *) 0 ;
36118 wxMenu *arg2 = (wxMenu *) 0 ;
36119 int arg3 = (int) -1 ;
36120 int arg4 = (int) -1 ;
36121 bool result;
36122 void *argp1 = 0 ;
36123 int res1 = 0 ;
36124 void *argp2 = 0 ;
36125 int res2 = 0 ;
36126 int val3 ;
36127 int ecode3 = 0 ;
36128 int val4 ;
36129 int ecode4 = 0 ;
36130 PyObject * obj0 = 0 ;
36131 PyObject * obj1 = 0 ;
36132 PyObject * obj2 = 0 ;
36133 PyObject * obj3 = 0 ;
36134 char * kwnames[] = {
36135 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36136 };
36137
36138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36140 if (!SWIG_IsOK(res1)) {
36141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36142 }
36143 arg1 = reinterpret_cast< wxWindow * >(argp1);
36144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36145 if (!SWIG_IsOK(res2)) {
36146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36147 }
36148 arg2 = reinterpret_cast< wxMenu * >(argp2);
36149 if (obj2) {
36150 ecode3 = SWIG_AsVal_int(obj2, &val3);
36151 if (!SWIG_IsOK(ecode3)) {
36152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36153 }
36154 arg3 = static_cast< int >(val3);
36155 }
36156 if (obj3) {
36157 ecode4 = SWIG_AsVal_int(obj3, &val4);
36158 if (!SWIG_IsOK(ecode4)) {
36159 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36160 }
36161 arg4 = static_cast< int >(val4);
36162 }
36163 {
36164 PyThreadState* __tstate = wxPyBeginAllowThreads();
36165 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36166 wxPyEndAllowThreads(__tstate);
36167 if (PyErr_Occurred()) SWIG_fail;
36168 }
36169 {
36170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36171 }
36172 return resultobj;
36173 fail:
36174 return NULL;
36175 }
36176
36177
36178 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36179 PyObject *resultobj = 0;
36180 wxWindow *arg1 = (wxWindow *) 0 ;
36181 wxMenu *arg2 = (wxMenu *) 0 ;
36182 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36183 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36184 bool result;
36185 void *argp1 = 0 ;
36186 int res1 = 0 ;
36187 void *argp2 = 0 ;
36188 int res2 = 0 ;
36189 wxPoint temp3 ;
36190 PyObject * obj0 = 0 ;
36191 PyObject * obj1 = 0 ;
36192 PyObject * obj2 = 0 ;
36193 char * kwnames[] = {
36194 (char *) "self",(char *) "menu",(char *) "pos", NULL
36195 };
36196
36197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36199 if (!SWIG_IsOK(res1)) {
36200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36201 }
36202 arg1 = reinterpret_cast< wxWindow * >(argp1);
36203 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36204 if (!SWIG_IsOK(res2)) {
36205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36206 }
36207 arg2 = reinterpret_cast< wxMenu * >(argp2);
36208 if (obj2) {
36209 {
36210 arg3 = &temp3;
36211 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36212 }
36213 }
36214 {
36215 PyThreadState* __tstate = wxPyBeginAllowThreads();
36216 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36217 wxPyEndAllowThreads(__tstate);
36218 if (PyErr_Occurred()) SWIG_fail;
36219 }
36220 {
36221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36222 }
36223 return resultobj;
36224 fail:
36225 return NULL;
36226 }
36227
36228
36229 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36230 PyObject *resultobj = 0;
36231 wxWindow *arg1 = (wxWindow *) 0 ;
36232 long result;
36233 void *argp1 = 0 ;
36234 int res1 = 0 ;
36235 PyObject *swig_obj[1] ;
36236
36237 if (!args) SWIG_fail;
36238 swig_obj[0] = args;
36239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36240 if (!SWIG_IsOK(res1)) {
36241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36242 }
36243 arg1 = reinterpret_cast< wxWindow * >(argp1);
36244 {
36245 PyThreadState* __tstate = wxPyBeginAllowThreads();
36246 result = (long)wxWindow_GetHandle(arg1);
36247 wxPyEndAllowThreads(__tstate);
36248 if (PyErr_Occurred()) SWIG_fail;
36249 }
36250 resultobj = SWIG_From_long(static_cast< long >(result));
36251 return resultobj;
36252 fail:
36253 return NULL;
36254 }
36255
36256
36257 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36258 PyObject *resultobj = 0;
36259 wxWindow *arg1 = (wxWindow *) 0 ;
36260 long arg2 ;
36261 void *argp1 = 0 ;
36262 int res1 = 0 ;
36263 long val2 ;
36264 int ecode2 = 0 ;
36265 PyObject * obj0 = 0 ;
36266 PyObject * obj1 = 0 ;
36267 char * kwnames[] = {
36268 (char *) "self",(char *) "handle", NULL
36269 };
36270
36271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36273 if (!SWIG_IsOK(res1)) {
36274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36275 }
36276 arg1 = reinterpret_cast< wxWindow * >(argp1);
36277 ecode2 = SWIG_AsVal_long(obj1, &val2);
36278 if (!SWIG_IsOK(ecode2)) {
36279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36280 }
36281 arg2 = static_cast< long >(val2);
36282 {
36283 PyThreadState* __tstate = wxPyBeginAllowThreads();
36284 wxWindow_AssociateHandle(arg1,arg2);
36285 wxPyEndAllowThreads(__tstate);
36286 if (PyErr_Occurred()) SWIG_fail;
36287 }
36288 resultobj = SWIG_Py_Void();
36289 return resultobj;
36290 fail:
36291 return NULL;
36292 }
36293
36294
36295 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36296 PyObject *resultobj = 0;
36297 wxWindow *arg1 = (wxWindow *) 0 ;
36298 void *argp1 = 0 ;
36299 int res1 = 0 ;
36300 PyObject *swig_obj[1] ;
36301
36302 if (!args) SWIG_fail;
36303 swig_obj[0] = args;
36304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36305 if (!SWIG_IsOK(res1)) {
36306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36307 }
36308 arg1 = reinterpret_cast< wxWindow * >(argp1);
36309 {
36310 PyThreadState* __tstate = wxPyBeginAllowThreads();
36311 (arg1)->DissociateHandle();
36312 wxPyEndAllowThreads(__tstate);
36313 if (PyErr_Occurred()) SWIG_fail;
36314 }
36315 resultobj = SWIG_Py_Void();
36316 return resultobj;
36317 fail:
36318 return NULL;
36319 }
36320
36321
36322 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36323 PyObject *resultobj = 0;
36324 wxWindow *arg1 = (wxWindow *) 0 ;
36325 int arg2 ;
36326 bool result;
36327 void *argp1 = 0 ;
36328 int res1 = 0 ;
36329 int val2 ;
36330 int ecode2 = 0 ;
36331 PyObject * obj0 = 0 ;
36332 PyObject * obj1 = 0 ;
36333 char * kwnames[] = {
36334 (char *) "self",(char *) "orient", NULL
36335 };
36336
36337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36339 if (!SWIG_IsOK(res1)) {
36340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36341 }
36342 arg1 = reinterpret_cast< wxWindow * >(argp1);
36343 ecode2 = SWIG_AsVal_int(obj1, &val2);
36344 if (!SWIG_IsOK(ecode2)) {
36345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36346 }
36347 arg2 = static_cast< int >(val2);
36348 {
36349 PyThreadState* __tstate = wxPyBeginAllowThreads();
36350 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36351 wxPyEndAllowThreads(__tstate);
36352 if (PyErr_Occurred()) SWIG_fail;
36353 }
36354 {
36355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36356 }
36357 return resultobj;
36358 fail:
36359 return NULL;
36360 }
36361
36362
36363 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36364 PyObject *resultobj = 0;
36365 wxWindow *arg1 = (wxWindow *) 0 ;
36366 int arg2 ;
36367 int arg3 ;
36368 int arg4 ;
36369 int arg5 ;
36370 bool arg6 = (bool) true ;
36371 void *argp1 = 0 ;
36372 int res1 = 0 ;
36373 int val2 ;
36374 int ecode2 = 0 ;
36375 int val3 ;
36376 int ecode3 = 0 ;
36377 int val4 ;
36378 int ecode4 = 0 ;
36379 int val5 ;
36380 int ecode5 = 0 ;
36381 bool val6 ;
36382 int ecode6 = 0 ;
36383 PyObject * obj0 = 0 ;
36384 PyObject * obj1 = 0 ;
36385 PyObject * obj2 = 0 ;
36386 PyObject * obj3 = 0 ;
36387 PyObject * obj4 = 0 ;
36388 PyObject * obj5 = 0 ;
36389 char * kwnames[] = {
36390 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36391 };
36392
36393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36395 if (!SWIG_IsOK(res1)) {
36396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36397 }
36398 arg1 = reinterpret_cast< wxWindow * >(argp1);
36399 ecode2 = SWIG_AsVal_int(obj1, &val2);
36400 if (!SWIG_IsOK(ecode2)) {
36401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36402 }
36403 arg2 = static_cast< int >(val2);
36404 ecode3 = SWIG_AsVal_int(obj2, &val3);
36405 if (!SWIG_IsOK(ecode3)) {
36406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36407 }
36408 arg3 = static_cast< int >(val3);
36409 ecode4 = SWIG_AsVal_int(obj3, &val4);
36410 if (!SWIG_IsOK(ecode4)) {
36411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36412 }
36413 arg4 = static_cast< int >(val4);
36414 ecode5 = SWIG_AsVal_int(obj4, &val5);
36415 if (!SWIG_IsOK(ecode5)) {
36416 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36417 }
36418 arg5 = static_cast< int >(val5);
36419 if (obj5) {
36420 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36421 if (!SWIG_IsOK(ecode6)) {
36422 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36423 }
36424 arg6 = static_cast< bool >(val6);
36425 }
36426 {
36427 PyThreadState* __tstate = wxPyBeginAllowThreads();
36428 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36429 wxPyEndAllowThreads(__tstate);
36430 if (PyErr_Occurred()) SWIG_fail;
36431 }
36432 resultobj = SWIG_Py_Void();
36433 return resultobj;
36434 fail:
36435 return NULL;
36436 }
36437
36438
36439 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36440 PyObject *resultobj = 0;
36441 wxWindow *arg1 = (wxWindow *) 0 ;
36442 int arg2 ;
36443 int arg3 ;
36444 bool arg4 = (bool) true ;
36445 void *argp1 = 0 ;
36446 int res1 = 0 ;
36447 int val2 ;
36448 int ecode2 = 0 ;
36449 int val3 ;
36450 int ecode3 = 0 ;
36451 bool val4 ;
36452 int ecode4 = 0 ;
36453 PyObject * obj0 = 0 ;
36454 PyObject * obj1 = 0 ;
36455 PyObject * obj2 = 0 ;
36456 PyObject * obj3 = 0 ;
36457 char * kwnames[] = {
36458 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36459 };
36460
36461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36463 if (!SWIG_IsOK(res1)) {
36464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36465 }
36466 arg1 = reinterpret_cast< wxWindow * >(argp1);
36467 ecode2 = SWIG_AsVal_int(obj1, &val2);
36468 if (!SWIG_IsOK(ecode2)) {
36469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36470 }
36471 arg2 = static_cast< int >(val2);
36472 ecode3 = SWIG_AsVal_int(obj2, &val3);
36473 if (!SWIG_IsOK(ecode3)) {
36474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36475 }
36476 arg3 = static_cast< int >(val3);
36477 if (obj3) {
36478 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36479 if (!SWIG_IsOK(ecode4)) {
36480 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36481 }
36482 arg4 = static_cast< bool >(val4);
36483 }
36484 {
36485 PyThreadState* __tstate = wxPyBeginAllowThreads();
36486 (arg1)->SetScrollPos(arg2,arg3,arg4);
36487 wxPyEndAllowThreads(__tstate);
36488 if (PyErr_Occurred()) SWIG_fail;
36489 }
36490 resultobj = SWIG_Py_Void();
36491 return resultobj;
36492 fail:
36493 return NULL;
36494 }
36495
36496
36497 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36498 PyObject *resultobj = 0;
36499 wxWindow *arg1 = (wxWindow *) 0 ;
36500 int arg2 ;
36501 int result;
36502 void *argp1 = 0 ;
36503 int res1 = 0 ;
36504 int val2 ;
36505 int ecode2 = 0 ;
36506 PyObject * obj0 = 0 ;
36507 PyObject * obj1 = 0 ;
36508 char * kwnames[] = {
36509 (char *) "self",(char *) "orientation", NULL
36510 };
36511
36512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36514 if (!SWIG_IsOK(res1)) {
36515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36516 }
36517 arg1 = reinterpret_cast< wxWindow * >(argp1);
36518 ecode2 = SWIG_AsVal_int(obj1, &val2);
36519 if (!SWIG_IsOK(ecode2)) {
36520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36521 }
36522 arg2 = static_cast< int >(val2);
36523 {
36524 PyThreadState* __tstate = wxPyBeginAllowThreads();
36525 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36526 wxPyEndAllowThreads(__tstate);
36527 if (PyErr_Occurred()) SWIG_fail;
36528 }
36529 resultobj = SWIG_From_int(static_cast< int >(result));
36530 return resultobj;
36531 fail:
36532 return NULL;
36533 }
36534
36535
36536 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36537 PyObject *resultobj = 0;
36538 wxWindow *arg1 = (wxWindow *) 0 ;
36539 int arg2 ;
36540 int result;
36541 void *argp1 = 0 ;
36542 int res1 = 0 ;
36543 int val2 ;
36544 int ecode2 = 0 ;
36545 PyObject * obj0 = 0 ;
36546 PyObject * obj1 = 0 ;
36547 char * kwnames[] = {
36548 (char *) "self",(char *) "orientation", NULL
36549 };
36550
36551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36553 if (!SWIG_IsOK(res1)) {
36554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36555 }
36556 arg1 = reinterpret_cast< wxWindow * >(argp1);
36557 ecode2 = SWIG_AsVal_int(obj1, &val2);
36558 if (!SWIG_IsOK(ecode2)) {
36559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36560 }
36561 arg2 = static_cast< int >(val2);
36562 {
36563 PyThreadState* __tstate = wxPyBeginAllowThreads();
36564 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36565 wxPyEndAllowThreads(__tstate);
36566 if (PyErr_Occurred()) SWIG_fail;
36567 }
36568 resultobj = SWIG_From_int(static_cast< int >(result));
36569 return resultobj;
36570 fail:
36571 return NULL;
36572 }
36573
36574
36575 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36576 PyObject *resultobj = 0;
36577 wxWindow *arg1 = (wxWindow *) 0 ;
36578 int arg2 ;
36579 int result;
36580 void *argp1 = 0 ;
36581 int res1 = 0 ;
36582 int val2 ;
36583 int ecode2 = 0 ;
36584 PyObject * obj0 = 0 ;
36585 PyObject * obj1 = 0 ;
36586 char * kwnames[] = {
36587 (char *) "self",(char *) "orientation", NULL
36588 };
36589
36590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36592 if (!SWIG_IsOK(res1)) {
36593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36594 }
36595 arg1 = reinterpret_cast< wxWindow * >(argp1);
36596 ecode2 = SWIG_AsVal_int(obj1, &val2);
36597 if (!SWIG_IsOK(ecode2)) {
36598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36599 }
36600 arg2 = static_cast< int >(val2);
36601 {
36602 PyThreadState* __tstate = wxPyBeginAllowThreads();
36603 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36604 wxPyEndAllowThreads(__tstate);
36605 if (PyErr_Occurred()) SWIG_fail;
36606 }
36607 resultobj = SWIG_From_int(static_cast< int >(result));
36608 return resultobj;
36609 fail:
36610 return NULL;
36611 }
36612
36613
36614 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36615 PyObject *resultobj = 0;
36616 wxWindow *arg1 = (wxWindow *) 0 ;
36617 int arg2 ;
36618 int arg3 ;
36619 wxRect *arg4 = (wxRect *) NULL ;
36620 void *argp1 = 0 ;
36621 int res1 = 0 ;
36622 int val2 ;
36623 int ecode2 = 0 ;
36624 int val3 ;
36625 int ecode3 = 0 ;
36626 void *argp4 = 0 ;
36627 int res4 = 0 ;
36628 PyObject * obj0 = 0 ;
36629 PyObject * obj1 = 0 ;
36630 PyObject * obj2 = 0 ;
36631 PyObject * obj3 = 0 ;
36632 char * kwnames[] = {
36633 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36634 };
36635
36636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36638 if (!SWIG_IsOK(res1)) {
36639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36640 }
36641 arg1 = reinterpret_cast< wxWindow * >(argp1);
36642 ecode2 = SWIG_AsVal_int(obj1, &val2);
36643 if (!SWIG_IsOK(ecode2)) {
36644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36645 }
36646 arg2 = static_cast< int >(val2);
36647 ecode3 = SWIG_AsVal_int(obj2, &val3);
36648 if (!SWIG_IsOK(ecode3)) {
36649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36650 }
36651 arg3 = static_cast< int >(val3);
36652 if (obj3) {
36653 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36654 if (!SWIG_IsOK(res4)) {
36655 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36656 }
36657 arg4 = reinterpret_cast< wxRect * >(argp4);
36658 }
36659 {
36660 PyThreadState* __tstate = wxPyBeginAllowThreads();
36661 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36662 wxPyEndAllowThreads(__tstate);
36663 if (PyErr_Occurred()) SWIG_fail;
36664 }
36665 resultobj = SWIG_Py_Void();
36666 return resultobj;
36667 fail:
36668 return NULL;
36669 }
36670
36671
36672 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36673 PyObject *resultobj = 0;
36674 wxWindow *arg1 = (wxWindow *) 0 ;
36675 int arg2 ;
36676 bool result;
36677 void *argp1 = 0 ;
36678 int res1 = 0 ;
36679 int val2 ;
36680 int ecode2 = 0 ;
36681 PyObject * obj0 = 0 ;
36682 PyObject * obj1 = 0 ;
36683 char * kwnames[] = {
36684 (char *) "self",(char *) "lines", NULL
36685 };
36686
36687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36689 if (!SWIG_IsOK(res1)) {
36690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36691 }
36692 arg1 = reinterpret_cast< wxWindow * >(argp1);
36693 ecode2 = SWIG_AsVal_int(obj1, &val2);
36694 if (!SWIG_IsOK(ecode2)) {
36695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36696 }
36697 arg2 = static_cast< int >(val2);
36698 {
36699 PyThreadState* __tstate = wxPyBeginAllowThreads();
36700 result = (bool)(arg1)->ScrollLines(arg2);
36701 wxPyEndAllowThreads(__tstate);
36702 if (PyErr_Occurred()) SWIG_fail;
36703 }
36704 {
36705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36706 }
36707 return resultobj;
36708 fail:
36709 return NULL;
36710 }
36711
36712
36713 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36714 PyObject *resultobj = 0;
36715 wxWindow *arg1 = (wxWindow *) 0 ;
36716 int arg2 ;
36717 bool result;
36718 void *argp1 = 0 ;
36719 int res1 = 0 ;
36720 int val2 ;
36721 int ecode2 = 0 ;
36722 PyObject * obj0 = 0 ;
36723 PyObject * obj1 = 0 ;
36724 char * kwnames[] = {
36725 (char *) "self",(char *) "pages", NULL
36726 };
36727
36728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36730 if (!SWIG_IsOK(res1)) {
36731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36732 }
36733 arg1 = reinterpret_cast< wxWindow * >(argp1);
36734 ecode2 = SWIG_AsVal_int(obj1, &val2);
36735 if (!SWIG_IsOK(ecode2)) {
36736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36737 }
36738 arg2 = static_cast< int >(val2);
36739 {
36740 PyThreadState* __tstate = wxPyBeginAllowThreads();
36741 result = (bool)(arg1)->ScrollPages(arg2);
36742 wxPyEndAllowThreads(__tstate);
36743 if (PyErr_Occurred()) SWIG_fail;
36744 }
36745 {
36746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36747 }
36748 return resultobj;
36749 fail:
36750 return NULL;
36751 }
36752
36753
36754 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36755 PyObject *resultobj = 0;
36756 wxWindow *arg1 = (wxWindow *) 0 ;
36757 bool result;
36758 void *argp1 = 0 ;
36759 int res1 = 0 ;
36760 PyObject *swig_obj[1] ;
36761
36762 if (!args) SWIG_fail;
36763 swig_obj[0] = args;
36764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36765 if (!SWIG_IsOK(res1)) {
36766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36767 }
36768 arg1 = reinterpret_cast< wxWindow * >(argp1);
36769 {
36770 PyThreadState* __tstate = wxPyBeginAllowThreads();
36771 result = (bool)(arg1)->LineUp();
36772 wxPyEndAllowThreads(__tstate);
36773 if (PyErr_Occurred()) SWIG_fail;
36774 }
36775 {
36776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36777 }
36778 return resultobj;
36779 fail:
36780 return NULL;
36781 }
36782
36783
36784 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36785 PyObject *resultobj = 0;
36786 wxWindow *arg1 = (wxWindow *) 0 ;
36787 bool result;
36788 void *argp1 = 0 ;
36789 int res1 = 0 ;
36790 PyObject *swig_obj[1] ;
36791
36792 if (!args) SWIG_fail;
36793 swig_obj[0] = args;
36794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36795 if (!SWIG_IsOK(res1)) {
36796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36797 }
36798 arg1 = reinterpret_cast< wxWindow * >(argp1);
36799 {
36800 PyThreadState* __tstate = wxPyBeginAllowThreads();
36801 result = (bool)(arg1)->LineDown();
36802 wxPyEndAllowThreads(__tstate);
36803 if (PyErr_Occurred()) SWIG_fail;
36804 }
36805 {
36806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36807 }
36808 return resultobj;
36809 fail:
36810 return NULL;
36811 }
36812
36813
36814 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36815 PyObject *resultobj = 0;
36816 wxWindow *arg1 = (wxWindow *) 0 ;
36817 bool result;
36818 void *argp1 = 0 ;
36819 int res1 = 0 ;
36820 PyObject *swig_obj[1] ;
36821
36822 if (!args) SWIG_fail;
36823 swig_obj[0] = args;
36824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36825 if (!SWIG_IsOK(res1)) {
36826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36827 }
36828 arg1 = reinterpret_cast< wxWindow * >(argp1);
36829 {
36830 PyThreadState* __tstate = wxPyBeginAllowThreads();
36831 result = (bool)(arg1)->PageUp();
36832 wxPyEndAllowThreads(__tstate);
36833 if (PyErr_Occurred()) SWIG_fail;
36834 }
36835 {
36836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36837 }
36838 return resultobj;
36839 fail:
36840 return NULL;
36841 }
36842
36843
36844 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36845 PyObject *resultobj = 0;
36846 wxWindow *arg1 = (wxWindow *) 0 ;
36847 bool result;
36848 void *argp1 = 0 ;
36849 int res1 = 0 ;
36850 PyObject *swig_obj[1] ;
36851
36852 if (!args) SWIG_fail;
36853 swig_obj[0] = args;
36854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36855 if (!SWIG_IsOK(res1)) {
36856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36857 }
36858 arg1 = reinterpret_cast< wxWindow * >(argp1);
36859 {
36860 PyThreadState* __tstate = wxPyBeginAllowThreads();
36861 result = (bool)(arg1)->PageDown();
36862 wxPyEndAllowThreads(__tstate);
36863 if (PyErr_Occurred()) SWIG_fail;
36864 }
36865 {
36866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36867 }
36868 return resultobj;
36869 fail:
36870 return NULL;
36871 }
36872
36873
36874 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36875 PyObject *resultobj = 0;
36876 wxWindow *arg1 = (wxWindow *) 0 ;
36877 wxString *arg2 = 0 ;
36878 void *argp1 = 0 ;
36879 int res1 = 0 ;
36880 bool temp2 = false ;
36881 PyObject * obj0 = 0 ;
36882 PyObject * obj1 = 0 ;
36883 char * kwnames[] = {
36884 (char *) "self",(char *) "text", NULL
36885 };
36886
36887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36889 if (!SWIG_IsOK(res1)) {
36890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36891 }
36892 arg1 = reinterpret_cast< wxWindow * >(argp1);
36893 {
36894 arg2 = wxString_in_helper(obj1);
36895 if (arg2 == NULL) SWIG_fail;
36896 temp2 = true;
36897 }
36898 {
36899 PyThreadState* __tstate = wxPyBeginAllowThreads();
36900 (arg1)->SetHelpText((wxString const &)*arg2);
36901 wxPyEndAllowThreads(__tstate);
36902 if (PyErr_Occurred()) SWIG_fail;
36903 }
36904 resultobj = SWIG_Py_Void();
36905 {
36906 if (temp2)
36907 delete arg2;
36908 }
36909 return resultobj;
36910 fail:
36911 {
36912 if (temp2)
36913 delete arg2;
36914 }
36915 return NULL;
36916 }
36917
36918
36919 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36920 PyObject *resultobj = 0;
36921 wxWindow *arg1 = (wxWindow *) 0 ;
36922 wxString *arg2 = 0 ;
36923 void *argp1 = 0 ;
36924 int res1 = 0 ;
36925 bool temp2 = false ;
36926 PyObject * obj0 = 0 ;
36927 PyObject * obj1 = 0 ;
36928 char * kwnames[] = {
36929 (char *) "self",(char *) "text", NULL
36930 };
36931
36932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36934 if (!SWIG_IsOK(res1)) {
36935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36936 }
36937 arg1 = reinterpret_cast< wxWindow * >(argp1);
36938 {
36939 arg2 = wxString_in_helper(obj1);
36940 if (arg2 == NULL) SWIG_fail;
36941 temp2 = true;
36942 }
36943 {
36944 PyThreadState* __tstate = wxPyBeginAllowThreads();
36945 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36946 wxPyEndAllowThreads(__tstate);
36947 if (PyErr_Occurred()) SWIG_fail;
36948 }
36949 resultobj = SWIG_Py_Void();
36950 {
36951 if (temp2)
36952 delete arg2;
36953 }
36954 return resultobj;
36955 fail:
36956 {
36957 if (temp2)
36958 delete arg2;
36959 }
36960 return NULL;
36961 }
36962
36963
36964 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36965 PyObject *resultobj = 0;
36966 wxWindow *arg1 = (wxWindow *) 0 ;
36967 wxPoint *arg2 = 0 ;
36968 wxHelpEvent::Origin arg3 ;
36969 wxString result;
36970 void *argp1 = 0 ;
36971 int res1 = 0 ;
36972 wxPoint temp2 ;
36973 void *argp3 ;
36974 int res3 = 0 ;
36975 PyObject * obj0 = 0 ;
36976 PyObject * obj1 = 0 ;
36977 PyObject * obj2 = 0 ;
36978 char * kwnames[] = {
36979 (char *) "self",(char *) "pt",(char *) "origin", NULL
36980 };
36981
36982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36984 if (!SWIG_IsOK(res1)) {
36985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
36986 }
36987 arg1 = reinterpret_cast< wxWindow * >(argp1);
36988 {
36989 arg2 = &temp2;
36990 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36991 }
36992 {
36993 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
36994 if (!SWIG_IsOK(res3)) {
36995 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36996 }
36997 if (!argp3) {
36998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36999 } else {
37000 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37001 arg3 = *temp;
37002 if (SWIG_IsNewObj(res3)) delete temp;
37003 }
37004 }
37005 {
37006 PyThreadState* __tstate = wxPyBeginAllowThreads();
37007 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37008 wxPyEndAllowThreads(__tstate);
37009 if (PyErr_Occurred()) SWIG_fail;
37010 }
37011 {
37012 #if wxUSE_UNICODE
37013 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37014 #else
37015 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37016 #endif
37017 }
37018 return resultobj;
37019 fail:
37020 return NULL;
37021 }
37022
37023
37024 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37025 PyObject *resultobj = 0;
37026 wxWindow *arg1 = (wxWindow *) 0 ;
37027 wxString result;
37028 void *argp1 = 0 ;
37029 int res1 = 0 ;
37030 PyObject *swig_obj[1] ;
37031
37032 if (!args) SWIG_fail;
37033 swig_obj[0] = args;
37034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37035 if (!SWIG_IsOK(res1)) {
37036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37037 }
37038 arg1 = reinterpret_cast< wxWindow * >(argp1);
37039 {
37040 PyThreadState* __tstate = wxPyBeginAllowThreads();
37041 result = ((wxWindow const *)arg1)->GetHelpText();
37042 wxPyEndAllowThreads(__tstate);
37043 if (PyErr_Occurred()) SWIG_fail;
37044 }
37045 {
37046 #if wxUSE_UNICODE
37047 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37048 #else
37049 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37050 #endif
37051 }
37052 return resultobj;
37053 fail:
37054 return NULL;
37055 }
37056
37057
37058 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37059 PyObject *resultobj = 0;
37060 wxWindow *arg1 = (wxWindow *) 0 ;
37061 wxString *arg2 = 0 ;
37062 void *argp1 = 0 ;
37063 int res1 = 0 ;
37064 bool temp2 = false ;
37065 PyObject * obj0 = 0 ;
37066 PyObject * obj1 = 0 ;
37067 char * kwnames[] = {
37068 (char *) "self",(char *) "tip", NULL
37069 };
37070
37071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37073 if (!SWIG_IsOK(res1)) {
37074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37075 }
37076 arg1 = reinterpret_cast< wxWindow * >(argp1);
37077 {
37078 arg2 = wxString_in_helper(obj1);
37079 if (arg2 == NULL) SWIG_fail;
37080 temp2 = true;
37081 }
37082 {
37083 PyThreadState* __tstate = wxPyBeginAllowThreads();
37084 (arg1)->SetToolTip((wxString const &)*arg2);
37085 wxPyEndAllowThreads(__tstate);
37086 if (PyErr_Occurred()) SWIG_fail;
37087 }
37088 resultobj = SWIG_Py_Void();
37089 {
37090 if (temp2)
37091 delete arg2;
37092 }
37093 return resultobj;
37094 fail:
37095 {
37096 if (temp2)
37097 delete arg2;
37098 }
37099 return NULL;
37100 }
37101
37102
37103 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37104 PyObject *resultobj = 0;
37105 wxWindow *arg1 = (wxWindow *) 0 ;
37106 wxToolTip *arg2 = (wxToolTip *) 0 ;
37107 void *argp1 = 0 ;
37108 int res1 = 0 ;
37109 int res2 = 0 ;
37110 PyObject * obj0 = 0 ;
37111 PyObject * obj1 = 0 ;
37112 char * kwnames[] = {
37113 (char *) "self",(char *) "tip", NULL
37114 };
37115
37116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37118 if (!SWIG_IsOK(res1)) {
37119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37120 }
37121 arg1 = reinterpret_cast< wxWindow * >(argp1);
37122 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37123 if (!SWIG_IsOK(res2)) {
37124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37125 }
37126 {
37127 PyThreadState* __tstate = wxPyBeginAllowThreads();
37128 (arg1)->SetToolTip(arg2);
37129 wxPyEndAllowThreads(__tstate);
37130 if (PyErr_Occurred()) SWIG_fail;
37131 }
37132 resultobj = SWIG_Py_Void();
37133 return resultobj;
37134 fail:
37135 return NULL;
37136 }
37137
37138
37139 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37140 PyObject *resultobj = 0;
37141 wxWindow *arg1 = (wxWindow *) 0 ;
37142 wxToolTip *result = 0 ;
37143 void *argp1 = 0 ;
37144 int res1 = 0 ;
37145 PyObject *swig_obj[1] ;
37146
37147 if (!args) SWIG_fail;
37148 swig_obj[0] = args;
37149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37150 if (!SWIG_IsOK(res1)) {
37151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37152 }
37153 arg1 = reinterpret_cast< wxWindow * >(argp1);
37154 {
37155 PyThreadState* __tstate = wxPyBeginAllowThreads();
37156 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37157 wxPyEndAllowThreads(__tstate);
37158 if (PyErr_Occurred()) SWIG_fail;
37159 }
37160 {
37161 resultobj = wxPyMake_wxObject(result, (bool)0);
37162 }
37163 return resultobj;
37164 fail:
37165 return NULL;
37166 }
37167
37168
37169 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37170 PyObject *resultobj = 0;
37171 wxWindow *arg1 = (wxWindow *) 0 ;
37172 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37173 void *argp1 = 0 ;
37174 int res1 = 0 ;
37175 int res2 = 0 ;
37176 PyObject * obj0 = 0 ;
37177 PyObject * obj1 = 0 ;
37178 char * kwnames[] = {
37179 (char *) "self",(char *) "dropTarget", NULL
37180 };
37181
37182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37184 if (!SWIG_IsOK(res1)) {
37185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37186 }
37187 arg1 = reinterpret_cast< wxWindow * >(argp1);
37188 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37189 if (!SWIG_IsOK(res2)) {
37190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37191 }
37192 {
37193 PyThreadState* __tstate = wxPyBeginAllowThreads();
37194 (arg1)->SetDropTarget(arg2);
37195 wxPyEndAllowThreads(__tstate);
37196 if (PyErr_Occurred()) SWIG_fail;
37197 }
37198 resultobj = SWIG_Py_Void();
37199 return resultobj;
37200 fail:
37201 return NULL;
37202 }
37203
37204
37205 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37206 PyObject *resultobj = 0;
37207 wxWindow *arg1 = (wxWindow *) 0 ;
37208 wxPyDropTarget *result = 0 ;
37209 void *argp1 = 0 ;
37210 int res1 = 0 ;
37211 PyObject *swig_obj[1] ;
37212
37213 if (!args) SWIG_fail;
37214 swig_obj[0] = args;
37215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37216 if (!SWIG_IsOK(res1)) {
37217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37218 }
37219 arg1 = reinterpret_cast< wxWindow * >(argp1);
37220 {
37221 PyThreadState* __tstate = wxPyBeginAllowThreads();
37222 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37223 wxPyEndAllowThreads(__tstate);
37224 if (PyErr_Occurred()) SWIG_fail;
37225 }
37226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37227 return resultobj;
37228 fail:
37229 return NULL;
37230 }
37231
37232
37233 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37234 PyObject *resultobj = 0;
37235 wxWindow *arg1 = (wxWindow *) 0 ;
37236 bool arg2 ;
37237 void *argp1 = 0 ;
37238 int res1 = 0 ;
37239 bool val2 ;
37240 int ecode2 = 0 ;
37241 PyObject * obj0 = 0 ;
37242 PyObject * obj1 = 0 ;
37243 char * kwnames[] = {
37244 (char *) "self",(char *) "accept", NULL
37245 };
37246
37247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37249 if (!SWIG_IsOK(res1)) {
37250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37251 }
37252 arg1 = reinterpret_cast< wxWindow * >(argp1);
37253 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37254 if (!SWIG_IsOK(ecode2)) {
37255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37256 }
37257 arg2 = static_cast< bool >(val2);
37258 {
37259 PyThreadState* __tstate = wxPyBeginAllowThreads();
37260 wxWindow_DragAcceptFiles(arg1,arg2);
37261 wxPyEndAllowThreads(__tstate);
37262 if (PyErr_Occurred()) SWIG_fail;
37263 }
37264 resultobj = SWIG_Py_Void();
37265 return resultobj;
37266 fail:
37267 return NULL;
37268 }
37269
37270
37271 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37272 PyObject *resultobj = 0;
37273 wxWindow *arg1 = (wxWindow *) 0 ;
37274 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37275 void *argp1 = 0 ;
37276 int res1 = 0 ;
37277 int res2 = 0 ;
37278 PyObject * obj0 = 0 ;
37279 PyObject * obj1 = 0 ;
37280 char * kwnames[] = {
37281 (char *) "self",(char *) "constraints", NULL
37282 };
37283
37284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37286 if (!SWIG_IsOK(res1)) {
37287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37288 }
37289 arg1 = reinterpret_cast< wxWindow * >(argp1);
37290 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37291 if (!SWIG_IsOK(res2)) {
37292 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37293 }
37294 {
37295 PyThreadState* __tstate = wxPyBeginAllowThreads();
37296 (arg1)->SetConstraints(arg2);
37297 wxPyEndAllowThreads(__tstate);
37298 if (PyErr_Occurred()) SWIG_fail;
37299 }
37300 resultobj = SWIG_Py_Void();
37301 return resultobj;
37302 fail:
37303 return NULL;
37304 }
37305
37306
37307 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37308 PyObject *resultobj = 0;
37309 wxWindow *arg1 = (wxWindow *) 0 ;
37310 wxLayoutConstraints *result = 0 ;
37311 void *argp1 = 0 ;
37312 int res1 = 0 ;
37313 PyObject *swig_obj[1] ;
37314
37315 if (!args) SWIG_fail;
37316 swig_obj[0] = args;
37317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37318 if (!SWIG_IsOK(res1)) {
37319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37320 }
37321 arg1 = reinterpret_cast< wxWindow * >(argp1);
37322 {
37323 PyThreadState* __tstate = wxPyBeginAllowThreads();
37324 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37325 wxPyEndAllowThreads(__tstate);
37326 if (PyErr_Occurred()) SWIG_fail;
37327 }
37328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37329 return resultobj;
37330 fail:
37331 return NULL;
37332 }
37333
37334
37335 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37336 PyObject *resultobj = 0;
37337 wxWindow *arg1 = (wxWindow *) 0 ;
37338 bool arg2 ;
37339 void *argp1 = 0 ;
37340 int res1 = 0 ;
37341 bool val2 ;
37342 int ecode2 = 0 ;
37343 PyObject * obj0 = 0 ;
37344 PyObject * obj1 = 0 ;
37345 char * kwnames[] = {
37346 (char *) "self",(char *) "autoLayout", NULL
37347 };
37348
37349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37351 if (!SWIG_IsOK(res1)) {
37352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37353 }
37354 arg1 = reinterpret_cast< wxWindow * >(argp1);
37355 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37356 if (!SWIG_IsOK(ecode2)) {
37357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37358 }
37359 arg2 = static_cast< bool >(val2);
37360 {
37361 PyThreadState* __tstate = wxPyBeginAllowThreads();
37362 (arg1)->SetAutoLayout(arg2);
37363 wxPyEndAllowThreads(__tstate);
37364 if (PyErr_Occurred()) SWIG_fail;
37365 }
37366 resultobj = SWIG_Py_Void();
37367 return resultobj;
37368 fail:
37369 return NULL;
37370 }
37371
37372
37373 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37374 PyObject *resultobj = 0;
37375 wxWindow *arg1 = (wxWindow *) 0 ;
37376 bool result;
37377 void *argp1 = 0 ;
37378 int res1 = 0 ;
37379 PyObject *swig_obj[1] ;
37380
37381 if (!args) SWIG_fail;
37382 swig_obj[0] = args;
37383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37384 if (!SWIG_IsOK(res1)) {
37385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37386 }
37387 arg1 = reinterpret_cast< wxWindow * >(argp1);
37388 {
37389 PyThreadState* __tstate = wxPyBeginAllowThreads();
37390 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37391 wxPyEndAllowThreads(__tstate);
37392 if (PyErr_Occurred()) SWIG_fail;
37393 }
37394 {
37395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37396 }
37397 return resultobj;
37398 fail:
37399 return NULL;
37400 }
37401
37402
37403 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37404 PyObject *resultobj = 0;
37405 wxWindow *arg1 = (wxWindow *) 0 ;
37406 bool result;
37407 void *argp1 = 0 ;
37408 int res1 = 0 ;
37409 PyObject *swig_obj[1] ;
37410
37411 if (!args) SWIG_fail;
37412 swig_obj[0] = args;
37413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37414 if (!SWIG_IsOK(res1)) {
37415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37416 }
37417 arg1 = reinterpret_cast< wxWindow * >(argp1);
37418 {
37419 PyThreadState* __tstate = wxPyBeginAllowThreads();
37420 result = (bool)(arg1)->Layout();
37421 wxPyEndAllowThreads(__tstate);
37422 if (PyErr_Occurred()) SWIG_fail;
37423 }
37424 {
37425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37426 }
37427 return resultobj;
37428 fail:
37429 return NULL;
37430 }
37431
37432
37433 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37434 PyObject *resultobj = 0;
37435 wxWindow *arg1 = (wxWindow *) 0 ;
37436 wxSizer *arg2 = (wxSizer *) 0 ;
37437 bool arg3 = (bool) true ;
37438 void *argp1 = 0 ;
37439 int res1 = 0 ;
37440 int res2 = 0 ;
37441 bool val3 ;
37442 int ecode3 = 0 ;
37443 PyObject * obj0 = 0 ;
37444 PyObject * obj1 = 0 ;
37445 PyObject * obj2 = 0 ;
37446 char * kwnames[] = {
37447 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37448 };
37449
37450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37452 if (!SWIG_IsOK(res1)) {
37453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37454 }
37455 arg1 = reinterpret_cast< wxWindow * >(argp1);
37456 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37457 if (!SWIG_IsOK(res2)) {
37458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37459 }
37460 if (obj2) {
37461 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37462 if (!SWIG_IsOK(ecode3)) {
37463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37464 }
37465 arg3 = static_cast< bool >(val3);
37466 }
37467 {
37468 PyThreadState* __tstate = wxPyBeginAllowThreads();
37469 (arg1)->SetSizer(arg2,arg3);
37470 wxPyEndAllowThreads(__tstate);
37471 if (PyErr_Occurred()) SWIG_fail;
37472 }
37473 resultobj = SWIG_Py_Void();
37474 return resultobj;
37475 fail:
37476 return NULL;
37477 }
37478
37479
37480 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37481 PyObject *resultobj = 0;
37482 wxWindow *arg1 = (wxWindow *) 0 ;
37483 wxSizer *arg2 = (wxSizer *) 0 ;
37484 bool arg3 = (bool) true ;
37485 void *argp1 = 0 ;
37486 int res1 = 0 ;
37487 int res2 = 0 ;
37488 bool val3 ;
37489 int ecode3 = 0 ;
37490 PyObject * obj0 = 0 ;
37491 PyObject * obj1 = 0 ;
37492 PyObject * obj2 = 0 ;
37493 char * kwnames[] = {
37494 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37495 };
37496
37497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37499 if (!SWIG_IsOK(res1)) {
37500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37501 }
37502 arg1 = reinterpret_cast< wxWindow * >(argp1);
37503 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37504 if (!SWIG_IsOK(res2)) {
37505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37506 }
37507 if (obj2) {
37508 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37509 if (!SWIG_IsOK(ecode3)) {
37510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37511 }
37512 arg3 = static_cast< bool >(val3);
37513 }
37514 {
37515 PyThreadState* __tstate = wxPyBeginAllowThreads();
37516 (arg1)->SetSizerAndFit(arg2,arg3);
37517 wxPyEndAllowThreads(__tstate);
37518 if (PyErr_Occurred()) SWIG_fail;
37519 }
37520 resultobj = SWIG_Py_Void();
37521 return resultobj;
37522 fail:
37523 return NULL;
37524 }
37525
37526
37527 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37528 PyObject *resultobj = 0;
37529 wxWindow *arg1 = (wxWindow *) 0 ;
37530 wxSizer *result = 0 ;
37531 void *argp1 = 0 ;
37532 int res1 = 0 ;
37533 PyObject *swig_obj[1] ;
37534
37535 if (!args) SWIG_fail;
37536 swig_obj[0] = args;
37537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37538 if (!SWIG_IsOK(res1)) {
37539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37540 }
37541 arg1 = reinterpret_cast< wxWindow * >(argp1);
37542 {
37543 PyThreadState* __tstate = wxPyBeginAllowThreads();
37544 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37545 wxPyEndAllowThreads(__tstate);
37546 if (PyErr_Occurred()) SWIG_fail;
37547 }
37548 {
37549 resultobj = wxPyMake_wxObject(result, (bool)0);
37550 }
37551 return resultobj;
37552 fail:
37553 return NULL;
37554 }
37555
37556
37557 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37558 PyObject *resultobj = 0;
37559 wxWindow *arg1 = (wxWindow *) 0 ;
37560 wxSizer *arg2 = (wxSizer *) 0 ;
37561 void *argp1 = 0 ;
37562 int res1 = 0 ;
37563 void *argp2 = 0 ;
37564 int res2 = 0 ;
37565 PyObject * obj0 = 0 ;
37566 PyObject * obj1 = 0 ;
37567 char * kwnames[] = {
37568 (char *) "self",(char *) "sizer", NULL
37569 };
37570
37571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37573 if (!SWIG_IsOK(res1)) {
37574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37575 }
37576 arg1 = reinterpret_cast< wxWindow * >(argp1);
37577 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37578 if (!SWIG_IsOK(res2)) {
37579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37580 }
37581 arg2 = reinterpret_cast< wxSizer * >(argp2);
37582 {
37583 PyThreadState* __tstate = wxPyBeginAllowThreads();
37584 (arg1)->SetContainingSizer(arg2);
37585 wxPyEndAllowThreads(__tstate);
37586 if (PyErr_Occurred()) SWIG_fail;
37587 }
37588 resultobj = SWIG_Py_Void();
37589 return resultobj;
37590 fail:
37591 return NULL;
37592 }
37593
37594
37595 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37596 PyObject *resultobj = 0;
37597 wxWindow *arg1 = (wxWindow *) 0 ;
37598 wxSizer *result = 0 ;
37599 void *argp1 = 0 ;
37600 int res1 = 0 ;
37601 PyObject *swig_obj[1] ;
37602
37603 if (!args) SWIG_fail;
37604 swig_obj[0] = args;
37605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37606 if (!SWIG_IsOK(res1)) {
37607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37608 }
37609 arg1 = reinterpret_cast< wxWindow * >(argp1);
37610 {
37611 PyThreadState* __tstate = wxPyBeginAllowThreads();
37612 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37613 wxPyEndAllowThreads(__tstate);
37614 if (PyErr_Occurred()) SWIG_fail;
37615 }
37616 {
37617 resultobj = wxPyMake_wxObject(result, (bool)0);
37618 }
37619 return resultobj;
37620 fail:
37621 return NULL;
37622 }
37623
37624
37625 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37626 PyObject *resultobj = 0;
37627 wxWindow *arg1 = (wxWindow *) 0 ;
37628 void *argp1 = 0 ;
37629 int res1 = 0 ;
37630 PyObject *swig_obj[1] ;
37631
37632 if (!args) SWIG_fail;
37633 swig_obj[0] = args;
37634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37635 if (!SWIG_IsOK(res1)) {
37636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37637 }
37638 arg1 = reinterpret_cast< wxWindow * >(argp1);
37639 {
37640 PyThreadState* __tstate = wxPyBeginAllowThreads();
37641 (arg1)->InheritAttributes();
37642 wxPyEndAllowThreads(__tstate);
37643 if (PyErr_Occurred()) SWIG_fail;
37644 }
37645 resultobj = SWIG_Py_Void();
37646 return resultobj;
37647 fail:
37648 return NULL;
37649 }
37650
37651
37652 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37653 PyObject *resultobj = 0;
37654 wxWindow *arg1 = (wxWindow *) 0 ;
37655 bool result;
37656 void *argp1 = 0 ;
37657 int res1 = 0 ;
37658 PyObject *swig_obj[1] ;
37659
37660 if (!args) SWIG_fail;
37661 swig_obj[0] = args;
37662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37663 if (!SWIG_IsOK(res1)) {
37664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37665 }
37666 arg1 = reinterpret_cast< wxWindow * >(argp1);
37667 {
37668 PyThreadState* __tstate = wxPyBeginAllowThreads();
37669 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37670 wxPyEndAllowThreads(__tstate);
37671 if (PyErr_Occurred()) SWIG_fail;
37672 }
37673 {
37674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37675 }
37676 return resultobj;
37677 fail:
37678 return NULL;
37679 }
37680
37681
37682 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37683 PyObject *obj;
37684 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37685 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37686 return SWIG_Py_Void();
37687 }
37688
37689 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37690 return SWIG_Python_InitShadowInstance(args);
37691 }
37692
37693 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37694 PyObject *resultobj = 0;
37695 long arg1 ;
37696 wxWindow *arg2 = (wxWindow *) NULL ;
37697 wxWindow *result = 0 ;
37698 long val1 ;
37699 int ecode1 = 0 ;
37700 void *argp2 = 0 ;
37701 int res2 = 0 ;
37702 PyObject * obj0 = 0 ;
37703 PyObject * obj1 = 0 ;
37704 char * kwnames[] = {
37705 (char *) "id",(char *) "parent", NULL
37706 };
37707
37708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37709 ecode1 = SWIG_AsVal_long(obj0, &val1);
37710 if (!SWIG_IsOK(ecode1)) {
37711 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37712 }
37713 arg1 = static_cast< long >(val1);
37714 if (obj1) {
37715 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37716 if (!SWIG_IsOK(res2)) {
37717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37718 }
37719 arg2 = reinterpret_cast< wxWindow * >(argp2);
37720 }
37721 {
37722 if (!wxPyCheckForApp()) SWIG_fail;
37723 PyThreadState* __tstate = wxPyBeginAllowThreads();
37724 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37725 wxPyEndAllowThreads(__tstate);
37726 if (PyErr_Occurred()) SWIG_fail;
37727 }
37728 {
37729 resultobj = wxPyMake_wxObject(result, 0);
37730 }
37731 return resultobj;
37732 fail:
37733 return NULL;
37734 }
37735
37736
37737 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37738 PyObject *resultobj = 0;
37739 wxString *arg1 = 0 ;
37740 wxWindow *arg2 = (wxWindow *) NULL ;
37741 wxWindow *result = 0 ;
37742 bool temp1 = false ;
37743 void *argp2 = 0 ;
37744 int res2 = 0 ;
37745 PyObject * obj0 = 0 ;
37746 PyObject * obj1 = 0 ;
37747 char * kwnames[] = {
37748 (char *) "name",(char *) "parent", NULL
37749 };
37750
37751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37752 {
37753 arg1 = wxString_in_helper(obj0);
37754 if (arg1 == NULL) SWIG_fail;
37755 temp1 = true;
37756 }
37757 if (obj1) {
37758 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37759 if (!SWIG_IsOK(res2)) {
37760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37761 }
37762 arg2 = reinterpret_cast< wxWindow * >(argp2);
37763 }
37764 {
37765 if (!wxPyCheckForApp()) SWIG_fail;
37766 PyThreadState* __tstate = wxPyBeginAllowThreads();
37767 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37768 wxPyEndAllowThreads(__tstate);
37769 if (PyErr_Occurred()) SWIG_fail;
37770 }
37771 {
37772 resultobj = wxPyMake_wxObject(result, 0);
37773 }
37774 {
37775 if (temp1)
37776 delete arg1;
37777 }
37778 return resultobj;
37779 fail:
37780 {
37781 if (temp1)
37782 delete arg1;
37783 }
37784 return NULL;
37785 }
37786
37787
37788 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37789 PyObject *resultobj = 0;
37790 wxString *arg1 = 0 ;
37791 wxWindow *arg2 = (wxWindow *) NULL ;
37792 wxWindow *result = 0 ;
37793 bool temp1 = false ;
37794 void *argp2 = 0 ;
37795 int res2 = 0 ;
37796 PyObject * obj0 = 0 ;
37797 PyObject * obj1 = 0 ;
37798 char * kwnames[] = {
37799 (char *) "label",(char *) "parent", NULL
37800 };
37801
37802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37803 {
37804 arg1 = wxString_in_helper(obj0);
37805 if (arg1 == NULL) SWIG_fail;
37806 temp1 = true;
37807 }
37808 if (obj1) {
37809 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37810 if (!SWIG_IsOK(res2)) {
37811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37812 }
37813 arg2 = reinterpret_cast< wxWindow * >(argp2);
37814 }
37815 {
37816 if (!wxPyCheckForApp()) SWIG_fail;
37817 PyThreadState* __tstate = wxPyBeginAllowThreads();
37818 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37819 wxPyEndAllowThreads(__tstate);
37820 if (PyErr_Occurred()) SWIG_fail;
37821 }
37822 {
37823 resultobj = wxPyMake_wxObject(result, 0);
37824 }
37825 {
37826 if (temp1)
37827 delete arg1;
37828 }
37829 return resultobj;
37830 fail:
37831 {
37832 if (temp1)
37833 delete arg1;
37834 }
37835 return NULL;
37836 }
37837
37838
37839 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37840 PyObject *resultobj = 0;
37841 wxWindow *arg1 = (wxWindow *) 0 ;
37842 unsigned long arg2 ;
37843 wxWindow *result = 0 ;
37844 void *argp1 = 0 ;
37845 int res1 = 0 ;
37846 unsigned long val2 ;
37847 int ecode2 = 0 ;
37848 PyObject * obj0 = 0 ;
37849 PyObject * obj1 = 0 ;
37850 char * kwnames[] = {
37851 (char *) "parent",(char *) "_hWnd", NULL
37852 };
37853
37854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37856 if (!SWIG_IsOK(res1)) {
37857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37858 }
37859 arg1 = reinterpret_cast< wxWindow * >(argp1);
37860 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37861 if (!SWIG_IsOK(ecode2)) {
37862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37863 }
37864 arg2 = static_cast< unsigned long >(val2);
37865 {
37866 PyThreadState* __tstate = wxPyBeginAllowThreads();
37867 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37868 wxPyEndAllowThreads(__tstate);
37869 if (PyErr_Occurred()) SWIG_fail;
37870 }
37871 {
37872 resultobj = wxPyMake_wxObject(result, 0);
37873 }
37874 return resultobj;
37875 fail:
37876 return NULL;
37877 }
37878
37879
37880 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37881 PyObject *resultobj = 0;
37882 PyObject *result = 0 ;
37883
37884 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37885 {
37886 PyThreadState* __tstate = wxPyBeginAllowThreads();
37887 result = (PyObject *)GetTopLevelWindows();
37888 wxPyEndAllowThreads(__tstate);
37889 if (PyErr_Occurred()) SWIG_fail;
37890 }
37891 resultobj = result;
37892 return resultobj;
37893 fail:
37894 return NULL;
37895 }
37896
37897
37898 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37899 PyObject *resultobj = 0;
37900 wxValidator *result = 0 ;
37901
37902 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37903 {
37904 PyThreadState* __tstate = wxPyBeginAllowThreads();
37905 result = (wxValidator *)new wxValidator();
37906 wxPyEndAllowThreads(__tstate);
37907 if (PyErr_Occurred()) SWIG_fail;
37908 }
37909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37910 return resultobj;
37911 fail:
37912 return NULL;
37913 }
37914
37915
37916 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37917 PyObject *resultobj = 0;
37918 wxValidator *arg1 = (wxValidator *) 0 ;
37919 wxValidator *result = 0 ;
37920 void *argp1 = 0 ;
37921 int res1 = 0 ;
37922 PyObject *swig_obj[1] ;
37923
37924 if (!args) SWIG_fail;
37925 swig_obj[0] = args;
37926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37927 if (!SWIG_IsOK(res1)) {
37928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37929 }
37930 arg1 = reinterpret_cast< wxValidator * >(argp1);
37931 {
37932 PyThreadState* __tstate = wxPyBeginAllowThreads();
37933 result = (wxValidator *)(arg1)->Clone();
37934 wxPyEndAllowThreads(__tstate);
37935 if (PyErr_Occurred()) SWIG_fail;
37936 }
37937 {
37938 resultobj = wxPyMake_wxObject(result, 0);
37939 }
37940 return resultobj;
37941 fail:
37942 return NULL;
37943 }
37944
37945
37946 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37947 PyObject *resultobj = 0;
37948 wxValidator *arg1 = (wxValidator *) 0 ;
37949 wxWindow *arg2 = (wxWindow *) 0 ;
37950 bool result;
37951 void *argp1 = 0 ;
37952 int res1 = 0 ;
37953 void *argp2 = 0 ;
37954 int res2 = 0 ;
37955 PyObject * obj0 = 0 ;
37956 PyObject * obj1 = 0 ;
37957 char * kwnames[] = {
37958 (char *) "self",(char *) "parent", NULL
37959 };
37960
37961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37963 if (!SWIG_IsOK(res1)) {
37964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37965 }
37966 arg1 = reinterpret_cast< wxValidator * >(argp1);
37967 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37968 if (!SWIG_IsOK(res2)) {
37969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37970 }
37971 arg2 = reinterpret_cast< wxWindow * >(argp2);
37972 {
37973 PyThreadState* __tstate = wxPyBeginAllowThreads();
37974 result = (bool)(arg1)->Validate(arg2);
37975 wxPyEndAllowThreads(__tstate);
37976 if (PyErr_Occurred()) SWIG_fail;
37977 }
37978 {
37979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37980 }
37981 return resultobj;
37982 fail:
37983 return NULL;
37984 }
37985
37986
37987 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37988 PyObject *resultobj = 0;
37989 wxValidator *arg1 = (wxValidator *) 0 ;
37990 bool result;
37991 void *argp1 = 0 ;
37992 int res1 = 0 ;
37993 PyObject *swig_obj[1] ;
37994
37995 if (!args) SWIG_fail;
37996 swig_obj[0] = args;
37997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37998 if (!SWIG_IsOK(res1)) {
37999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38000 }
38001 arg1 = reinterpret_cast< wxValidator * >(argp1);
38002 {
38003 PyThreadState* __tstate = wxPyBeginAllowThreads();
38004 result = (bool)(arg1)->TransferToWindow();
38005 wxPyEndAllowThreads(__tstate);
38006 if (PyErr_Occurred()) SWIG_fail;
38007 }
38008 {
38009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38010 }
38011 return resultobj;
38012 fail:
38013 return NULL;
38014 }
38015
38016
38017 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38018 PyObject *resultobj = 0;
38019 wxValidator *arg1 = (wxValidator *) 0 ;
38020 bool result;
38021 void *argp1 = 0 ;
38022 int res1 = 0 ;
38023 PyObject *swig_obj[1] ;
38024
38025 if (!args) SWIG_fail;
38026 swig_obj[0] = args;
38027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38028 if (!SWIG_IsOK(res1)) {
38029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38030 }
38031 arg1 = reinterpret_cast< wxValidator * >(argp1);
38032 {
38033 PyThreadState* __tstate = wxPyBeginAllowThreads();
38034 result = (bool)(arg1)->TransferFromWindow();
38035 wxPyEndAllowThreads(__tstate);
38036 if (PyErr_Occurred()) SWIG_fail;
38037 }
38038 {
38039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38040 }
38041 return resultobj;
38042 fail:
38043 return NULL;
38044 }
38045
38046
38047 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38048 PyObject *resultobj = 0;
38049 wxValidator *arg1 = (wxValidator *) 0 ;
38050 wxWindow *result = 0 ;
38051 void *argp1 = 0 ;
38052 int res1 = 0 ;
38053 PyObject *swig_obj[1] ;
38054
38055 if (!args) SWIG_fail;
38056 swig_obj[0] = args;
38057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38058 if (!SWIG_IsOK(res1)) {
38059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38060 }
38061 arg1 = reinterpret_cast< wxValidator * >(argp1);
38062 {
38063 PyThreadState* __tstate = wxPyBeginAllowThreads();
38064 result = (wxWindow *)(arg1)->GetWindow();
38065 wxPyEndAllowThreads(__tstate);
38066 if (PyErr_Occurred()) SWIG_fail;
38067 }
38068 {
38069 resultobj = wxPyMake_wxObject(result, 0);
38070 }
38071 return resultobj;
38072 fail:
38073 return NULL;
38074 }
38075
38076
38077 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38078 PyObject *resultobj = 0;
38079 wxValidator *arg1 = (wxValidator *) 0 ;
38080 wxWindow *arg2 = (wxWindow *) 0 ;
38081 void *argp1 = 0 ;
38082 int res1 = 0 ;
38083 void *argp2 = 0 ;
38084 int res2 = 0 ;
38085 PyObject * obj0 = 0 ;
38086 PyObject * obj1 = 0 ;
38087 char * kwnames[] = {
38088 (char *) "self",(char *) "window", NULL
38089 };
38090
38091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38093 if (!SWIG_IsOK(res1)) {
38094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38095 }
38096 arg1 = reinterpret_cast< wxValidator * >(argp1);
38097 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38098 if (!SWIG_IsOK(res2)) {
38099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38100 }
38101 arg2 = reinterpret_cast< wxWindow * >(argp2);
38102 {
38103 PyThreadState* __tstate = wxPyBeginAllowThreads();
38104 (arg1)->SetWindow(arg2);
38105 wxPyEndAllowThreads(__tstate);
38106 if (PyErr_Occurred()) SWIG_fail;
38107 }
38108 resultobj = SWIG_Py_Void();
38109 return resultobj;
38110 fail:
38111 return NULL;
38112 }
38113
38114
38115 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38116 PyObject *resultobj = 0;
38117 bool result;
38118
38119 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38120 {
38121 PyThreadState* __tstate = wxPyBeginAllowThreads();
38122 result = (bool)wxValidator::IsSilent();
38123 wxPyEndAllowThreads(__tstate);
38124 if (PyErr_Occurred()) SWIG_fail;
38125 }
38126 {
38127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38128 }
38129 return resultobj;
38130 fail:
38131 return NULL;
38132 }
38133
38134
38135 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38136 PyObject *resultobj = 0;
38137 int arg1 = (int) true ;
38138 int val1 ;
38139 int ecode1 = 0 ;
38140 PyObject * obj0 = 0 ;
38141 char * kwnames[] = {
38142 (char *) "doIt", NULL
38143 };
38144
38145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38146 if (obj0) {
38147 ecode1 = SWIG_AsVal_int(obj0, &val1);
38148 if (!SWIG_IsOK(ecode1)) {
38149 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38150 }
38151 arg1 = static_cast< int >(val1);
38152 }
38153 {
38154 PyThreadState* __tstate = wxPyBeginAllowThreads();
38155 wxValidator::SetBellOnError(arg1);
38156 wxPyEndAllowThreads(__tstate);
38157 if (PyErr_Occurred()) SWIG_fail;
38158 }
38159 resultobj = SWIG_Py_Void();
38160 return resultobj;
38161 fail:
38162 return NULL;
38163 }
38164
38165
38166 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38167 PyObject *obj;
38168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38169 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38170 return SWIG_Py_Void();
38171 }
38172
38173 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38174 return SWIG_Python_InitShadowInstance(args);
38175 }
38176
38177 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38178 PyObject *resultobj = 0;
38179 wxPyValidator *result = 0 ;
38180
38181 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38182 {
38183 PyThreadState* __tstate = wxPyBeginAllowThreads();
38184 result = (wxPyValidator *)new wxPyValidator();
38185 wxPyEndAllowThreads(__tstate);
38186 if (PyErr_Occurred()) SWIG_fail;
38187 }
38188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38189 return resultobj;
38190 fail:
38191 return NULL;
38192 }
38193
38194
38195 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38196 PyObject *resultobj = 0;
38197 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38198 PyObject *arg2 = (PyObject *) 0 ;
38199 PyObject *arg3 = (PyObject *) 0 ;
38200 int arg4 = (int) true ;
38201 void *argp1 = 0 ;
38202 int res1 = 0 ;
38203 int val4 ;
38204 int ecode4 = 0 ;
38205 PyObject * obj0 = 0 ;
38206 PyObject * obj1 = 0 ;
38207 PyObject * obj2 = 0 ;
38208 PyObject * obj3 = 0 ;
38209 char * kwnames[] = {
38210 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38211 };
38212
38213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38215 if (!SWIG_IsOK(res1)) {
38216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38217 }
38218 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38219 arg2 = obj1;
38220 arg3 = obj2;
38221 if (obj3) {
38222 ecode4 = SWIG_AsVal_int(obj3, &val4);
38223 if (!SWIG_IsOK(ecode4)) {
38224 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38225 }
38226 arg4 = static_cast< int >(val4);
38227 }
38228 {
38229 PyThreadState* __tstate = wxPyBeginAllowThreads();
38230 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38231 wxPyEndAllowThreads(__tstate);
38232 if (PyErr_Occurred()) SWIG_fail;
38233 }
38234 resultobj = SWIG_Py_Void();
38235 return resultobj;
38236 fail:
38237 return NULL;
38238 }
38239
38240
38241 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38242 PyObject *obj;
38243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38244 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38245 return SWIG_Py_Void();
38246 }
38247
38248 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38249 return SWIG_Python_InitShadowInstance(args);
38250 }
38251
38252 SWIGINTERN int DefaultValidator_set(PyObject *) {
38253 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38254 return 1;
38255 }
38256
38257
38258 SWIGINTERN PyObject *DefaultValidator_get(void) {
38259 PyObject *pyobj = 0;
38260
38261 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38262 return pyobj;
38263 }
38264
38265
38266 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38267 PyObject *resultobj = 0;
38268 wxString const &arg1_defvalue = wxPyEmptyString ;
38269 wxString *arg1 = (wxString *) &arg1_defvalue ;
38270 long arg2 = (long) 0 ;
38271 wxMenu *result = 0 ;
38272 bool temp1 = false ;
38273 long val2 ;
38274 int ecode2 = 0 ;
38275 PyObject * obj0 = 0 ;
38276 PyObject * obj1 = 0 ;
38277 char * kwnames[] = {
38278 (char *) "title",(char *) "style", NULL
38279 };
38280
38281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38282 if (obj0) {
38283 {
38284 arg1 = wxString_in_helper(obj0);
38285 if (arg1 == NULL) SWIG_fail;
38286 temp1 = true;
38287 }
38288 }
38289 if (obj1) {
38290 ecode2 = SWIG_AsVal_long(obj1, &val2);
38291 if (!SWIG_IsOK(ecode2)) {
38292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38293 }
38294 arg2 = static_cast< long >(val2);
38295 }
38296 {
38297 if (!wxPyCheckForApp()) SWIG_fail;
38298 PyThreadState* __tstate = wxPyBeginAllowThreads();
38299 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38300 wxPyEndAllowThreads(__tstate);
38301 if (PyErr_Occurred()) SWIG_fail;
38302 }
38303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38304 {
38305 if (temp1)
38306 delete arg1;
38307 }
38308 return resultobj;
38309 fail:
38310 {
38311 if (temp1)
38312 delete arg1;
38313 }
38314 return NULL;
38315 }
38316
38317
38318 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38319 PyObject *resultobj = 0;
38320 wxMenu *arg1 = (wxMenu *) 0 ;
38321 int arg2 ;
38322 wxString *arg3 = 0 ;
38323 wxString const &arg4_defvalue = wxPyEmptyString ;
38324 wxString *arg4 = (wxString *) &arg4_defvalue ;
38325 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38326 wxMenuItem *result = 0 ;
38327 void *argp1 = 0 ;
38328 int res1 = 0 ;
38329 int val2 ;
38330 int ecode2 = 0 ;
38331 bool temp3 = false ;
38332 bool temp4 = false ;
38333 int val5 ;
38334 int ecode5 = 0 ;
38335 PyObject * obj0 = 0 ;
38336 PyObject * obj1 = 0 ;
38337 PyObject * obj2 = 0 ;
38338 PyObject * obj3 = 0 ;
38339 PyObject * obj4 = 0 ;
38340 char * kwnames[] = {
38341 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38342 };
38343
38344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38346 if (!SWIG_IsOK(res1)) {
38347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38348 }
38349 arg1 = reinterpret_cast< wxMenu * >(argp1);
38350 ecode2 = SWIG_AsVal_int(obj1, &val2);
38351 if (!SWIG_IsOK(ecode2)) {
38352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38353 }
38354 arg2 = static_cast< int >(val2);
38355 {
38356 arg3 = wxString_in_helper(obj2);
38357 if (arg3 == NULL) SWIG_fail;
38358 temp3 = true;
38359 }
38360 if (obj3) {
38361 {
38362 arg4 = wxString_in_helper(obj3);
38363 if (arg4 == NULL) SWIG_fail;
38364 temp4 = true;
38365 }
38366 }
38367 if (obj4) {
38368 ecode5 = SWIG_AsVal_int(obj4, &val5);
38369 if (!SWIG_IsOK(ecode5)) {
38370 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38371 }
38372 arg5 = static_cast< wxItemKind >(val5);
38373 }
38374 {
38375 PyThreadState* __tstate = wxPyBeginAllowThreads();
38376 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38377 wxPyEndAllowThreads(__tstate);
38378 if (PyErr_Occurred()) SWIG_fail;
38379 }
38380 {
38381 resultobj = wxPyMake_wxObject(result, (bool)0);
38382 }
38383 {
38384 if (temp3)
38385 delete arg3;
38386 }
38387 {
38388 if (temp4)
38389 delete arg4;
38390 }
38391 return resultobj;
38392 fail:
38393 {
38394 if (temp3)
38395 delete arg3;
38396 }
38397 {
38398 if (temp4)
38399 delete arg4;
38400 }
38401 return NULL;
38402 }
38403
38404
38405 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38406 PyObject *resultobj = 0;
38407 wxMenu *arg1 = (wxMenu *) 0 ;
38408 wxMenuItem *result = 0 ;
38409 void *argp1 = 0 ;
38410 int res1 = 0 ;
38411 PyObject *swig_obj[1] ;
38412
38413 if (!args) SWIG_fail;
38414 swig_obj[0] = args;
38415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38416 if (!SWIG_IsOK(res1)) {
38417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38418 }
38419 arg1 = reinterpret_cast< wxMenu * >(argp1);
38420 {
38421 PyThreadState* __tstate = wxPyBeginAllowThreads();
38422 result = (wxMenuItem *)(arg1)->AppendSeparator();
38423 wxPyEndAllowThreads(__tstate);
38424 if (PyErr_Occurred()) SWIG_fail;
38425 }
38426 {
38427 resultobj = wxPyMake_wxObject(result, (bool)0);
38428 }
38429 return resultobj;
38430 fail:
38431 return NULL;
38432 }
38433
38434
38435 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38436 PyObject *resultobj = 0;
38437 wxMenu *arg1 = (wxMenu *) 0 ;
38438 int arg2 ;
38439 wxString *arg3 = 0 ;
38440 wxString const &arg4_defvalue = wxPyEmptyString ;
38441 wxString *arg4 = (wxString *) &arg4_defvalue ;
38442 wxMenuItem *result = 0 ;
38443 void *argp1 = 0 ;
38444 int res1 = 0 ;
38445 int val2 ;
38446 int ecode2 = 0 ;
38447 bool temp3 = false ;
38448 bool temp4 = false ;
38449 PyObject * obj0 = 0 ;
38450 PyObject * obj1 = 0 ;
38451 PyObject * obj2 = 0 ;
38452 PyObject * obj3 = 0 ;
38453 char * kwnames[] = {
38454 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38455 };
38456
38457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38459 if (!SWIG_IsOK(res1)) {
38460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38461 }
38462 arg1 = reinterpret_cast< wxMenu * >(argp1);
38463 ecode2 = SWIG_AsVal_int(obj1, &val2);
38464 if (!SWIG_IsOK(ecode2)) {
38465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38466 }
38467 arg2 = static_cast< int >(val2);
38468 {
38469 arg3 = wxString_in_helper(obj2);
38470 if (arg3 == NULL) SWIG_fail;
38471 temp3 = true;
38472 }
38473 if (obj3) {
38474 {
38475 arg4 = wxString_in_helper(obj3);
38476 if (arg4 == NULL) SWIG_fail;
38477 temp4 = true;
38478 }
38479 }
38480 {
38481 PyThreadState* __tstate = wxPyBeginAllowThreads();
38482 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38483 wxPyEndAllowThreads(__tstate);
38484 if (PyErr_Occurred()) SWIG_fail;
38485 }
38486 {
38487 resultobj = wxPyMake_wxObject(result, (bool)0);
38488 }
38489 {
38490 if (temp3)
38491 delete arg3;
38492 }
38493 {
38494 if (temp4)
38495 delete arg4;
38496 }
38497 return resultobj;
38498 fail:
38499 {
38500 if (temp3)
38501 delete arg3;
38502 }
38503 {
38504 if (temp4)
38505 delete arg4;
38506 }
38507 return NULL;
38508 }
38509
38510
38511 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38512 PyObject *resultobj = 0;
38513 wxMenu *arg1 = (wxMenu *) 0 ;
38514 int arg2 ;
38515 wxString *arg3 = 0 ;
38516 wxString const &arg4_defvalue = wxPyEmptyString ;
38517 wxString *arg4 = (wxString *) &arg4_defvalue ;
38518 wxMenuItem *result = 0 ;
38519 void *argp1 = 0 ;
38520 int res1 = 0 ;
38521 int val2 ;
38522 int ecode2 = 0 ;
38523 bool temp3 = false ;
38524 bool temp4 = false ;
38525 PyObject * obj0 = 0 ;
38526 PyObject * obj1 = 0 ;
38527 PyObject * obj2 = 0 ;
38528 PyObject * obj3 = 0 ;
38529 char * kwnames[] = {
38530 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38531 };
38532
38533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38535 if (!SWIG_IsOK(res1)) {
38536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38537 }
38538 arg1 = reinterpret_cast< wxMenu * >(argp1);
38539 ecode2 = SWIG_AsVal_int(obj1, &val2);
38540 if (!SWIG_IsOK(ecode2)) {
38541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38542 }
38543 arg2 = static_cast< int >(val2);
38544 {
38545 arg3 = wxString_in_helper(obj2);
38546 if (arg3 == NULL) SWIG_fail;
38547 temp3 = true;
38548 }
38549 if (obj3) {
38550 {
38551 arg4 = wxString_in_helper(obj3);
38552 if (arg4 == NULL) SWIG_fail;
38553 temp4 = true;
38554 }
38555 }
38556 {
38557 PyThreadState* __tstate = wxPyBeginAllowThreads();
38558 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38559 wxPyEndAllowThreads(__tstate);
38560 if (PyErr_Occurred()) SWIG_fail;
38561 }
38562 {
38563 resultobj = wxPyMake_wxObject(result, (bool)0);
38564 }
38565 {
38566 if (temp3)
38567 delete arg3;
38568 }
38569 {
38570 if (temp4)
38571 delete arg4;
38572 }
38573 return resultobj;
38574 fail:
38575 {
38576 if (temp3)
38577 delete arg3;
38578 }
38579 {
38580 if (temp4)
38581 delete arg4;
38582 }
38583 return NULL;
38584 }
38585
38586
38587 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38588 PyObject *resultobj = 0;
38589 wxMenu *arg1 = (wxMenu *) 0 ;
38590 int arg2 ;
38591 wxString *arg3 = 0 ;
38592 wxMenu *arg4 = (wxMenu *) 0 ;
38593 wxString const &arg5_defvalue = wxPyEmptyString ;
38594 wxString *arg5 = (wxString *) &arg5_defvalue ;
38595 wxMenuItem *result = 0 ;
38596 void *argp1 = 0 ;
38597 int res1 = 0 ;
38598 int val2 ;
38599 int ecode2 = 0 ;
38600 bool temp3 = false ;
38601 void *argp4 = 0 ;
38602 int res4 = 0 ;
38603 bool temp5 = false ;
38604 PyObject * obj0 = 0 ;
38605 PyObject * obj1 = 0 ;
38606 PyObject * obj2 = 0 ;
38607 PyObject * obj3 = 0 ;
38608 PyObject * obj4 = 0 ;
38609 char * kwnames[] = {
38610 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38611 };
38612
38613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38615 if (!SWIG_IsOK(res1)) {
38616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38617 }
38618 arg1 = reinterpret_cast< wxMenu * >(argp1);
38619 ecode2 = SWIG_AsVal_int(obj1, &val2);
38620 if (!SWIG_IsOK(ecode2)) {
38621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38622 }
38623 arg2 = static_cast< int >(val2);
38624 {
38625 arg3 = wxString_in_helper(obj2);
38626 if (arg3 == NULL) SWIG_fail;
38627 temp3 = true;
38628 }
38629 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38630 if (!SWIG_IsOK(res4)) {
38631 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38632 }
38633 arg4 = reinterpret_cast< wxMenu * >(argp4);
38634 if (obj4) {
38635 {
38636 arg5 = wxString_in_helper(obj4);
38637 if (arg5 == NULL) SWIG_fail;
38638 temp5 = true;
38639 }
38640 }
38641 {
38642 PyThreadState* __tstate = wxPyBeginAllowThreads();
38643 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38644 wxPyEndAllowThreads(__tstate);
38645 if (PyErr_Occurred()) SWIG_fail;
38646 }
38647 {
38648 resultobj = wxPyMake_wxObject(result, (bool)0);
38649 }
38650 {
38651 if (temp3)
38652 delete arg3;
38653 }
38654 {
38655 if (temp5)
38656 delete arg5;
38657 }
38658 return resultobj;
38659 fail:
38660 {
38661 if (temp3)
38662 delete arg3;
38663 }
38664 {
38665 if (temp5)
38666 delete arg5;
38667 }
38668 return NULL;
38669 }
38670
38671
38672 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38673 PyObject *resultobj = 0;
38674 wxMenu *arg1 = (wxMenu *) 0 ;
38675 wxMenu *arg2 = (wxMenu *) 0 ;
38676 wxString *arg3 = 0 ;
38677 wxString const &arg4_defvalue = wxPyEmptyString ;
38678 wxString *arg4 = (wxString *) &arg4_defvalue ;
38679 wxMenuItem *result = 0 ;
38680 void *argp1 = 0 ;
38681 int res1 = 0 ;
38682 void *argp2 = 0 ;
38683 int res2 = 0 ;
38684 bool temp3 = false ;
38685 bool temp4 = false ;
38686 PyObject * obj0 = 0 ;
38687 PyObject * obj1 = 0 ;
38688 PyObject * obj2 = 0 ;
38689 PyObject * obj3 = 0 ;
38690 char * kwnames[] = {
38691 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38692 };
38693
38694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38696 if (!SWIG_IsOK(res1)) {
38697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38698 }
38699 arg1 = reinterpret_cast< wxMenu * >(argp1);
38700 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38701 if (!SWIG_IsOK(res2)) {
38702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38703 }
38704 arg2 = reinterpret_cast< wxMenu * >(argp2);
38705 {
38706 arg3 = wxString_in_helper(obj2);
38707 if (arg3 == NULL) SWIG_fail;
38708 temp3 = true;
38709 }
38710 if (obj3) {
38711 {
38712 arg4 = wxString_in_helper(obj3);
38713 if (arg4 == NULL) SWIG_fail;
38714 temp4 = true;
38715 }
38716 }
38717 {
38718 PyThreadState* __tstate = wxPyBeginAllowThreads();
38719 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38720 wxPyEndAllowThreads(__tstate);
38721 if (PyErr_Occurred()) SWIG_fail;
38722 }
38723 {
38724 resultobj = wxPyMake_wxObject(result, (bool)0);
38725 }
38726 {
38727 if (temp3)
38728 delete arg3;
38729 }
38730 {
38731 if (temp4)
38732 delete arg4;
38733 }
38734 return resultobj;
38735 fail:
38736 {
38737 if (temp3)
38738 delete arg3;
38739 }
38740 {
38741 if (temp4)
38742 delete arg4;
38743 }
38744 return NULL;
38745 }
38746
38747
38748 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38749 PyObject *resultobj = 0;
38750 wxMenu *arg1 = (wxMenu *) 0 ;
38751 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38752 wxMenuItem *result = 0 ;
38753 void *argp1 = 0 ;
38754 int res1 = 0 ;
38755 int res2 = 0 ;
38756 PyObject * obj0 = 0 ;
38757 PyObject * obj1 = 0 ;
38758 char * kwnames[] = {
38759 (char *) "self",(char *) "item", NULL
38760 };
38761
38762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38764 if (!SWIG_IsOK(res1)) {
38765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38766 }
38767 arg1 = reinterpret_cast< wxMenu * >(argp1);
38768 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38769 if (!SWIG_IsOK(res2)) {
38770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38771 }
38772 {
38773 PyThreadState* __tstate = wxPyBeginAllowThreads();
38774 result = (wxMenuItem *)(arg1)->Append(arg2);
38775 wxPyEndAllowThreads(__tstate);
38776 if (PyErr_Occurred()) SWIG_fail;
38777 }
38778 {
38779 resultobj = wxPyMake_wxObject(result, (bool)0);
38780 }
38781 return resultobj;
38782 fail:
38783 return NULL;
38784 }
38785
38786
38787 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38788 PyObject *resultobj = 0;
38789 wxMenu *arg1 = (wxMenu *) 0 ;
38790 size_t arg2 ;
38791 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38792 wxMenuItem *result = 0 ;
38793 void *argp1 = 0 ;
38794 int res1 = 0 ;
38795 size_t val2 ;
38796 int ecode2 = 0 ;
38797 int res3 = 0 ;
38798 PyObject * obj0 = 0 ;
38799 PyObject * obj1 = 0 ;
38800 PyObject * obj2 = 0 ;
38801 char * kwnames[] = {
38802 (char *) "self",(char *) "pos",(char *) "item", NULL
38803 };
38804
38805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38807 if (!SWIG_IsOK(res1)) {
38808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38809 }
38810 arg1 = reinterpret_cast< wxMenu * >(argp1);
38811 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38812 if (!SWIG_IsOK(ecode2)) {
38813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38814 }
38815 arg2 = static_cast< size_t >(val2);
38816 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38817 if (!SWIG_IsOK(res3)) {
38818 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38819 }
38820 {
38821 PyThreadState* __tstate = wxPyBeginAllowThreads();
38822 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38823 wxPyEndAllowThreads(__tstate);
38824 if (PyErr_Occurred()) SWIG_fail;
38825 }
38826 {
38827 resultobj = wxPyMake_wxObject(result, (bool)0);
38828 }
38829 return resultobj;
38830 fail:
38831 return NULL;
38832 }
38833
38834
38835 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38836 PyObject *resultobj = 0;
38837 wxMenu *arg1 = (wxMenu *) 0 ;
38838 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38839 wxMenuItem *result = 0 ;
38840 void *argp1 = 0 ;
38841 int res1 = 0 ;
38842 int res2 = 0 ;
38843 PyObject * obj0 = 0 ;
38844 PyObject * obj1 = 0 ;
38845 char * kwnames[] = {
38846 (char *) "self",(char *) "item", NULL
38847 };
38848
38849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38851 if (!SWIG_IsOK(res1)) {
38852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38853 }
38854 arg1 = reinterpret_cast< wxMenu * >(argp1);
38855 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38856 if (!SWIG_IsOK(res2)) {
38857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38858 }
38859 {
38860 PyThreadState* __tstate = wxPyBeginAllowThreads();
38861 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38862 wxPyEndAllowThreads(__tstate);
38863 if (PyErr_Occurred()) SWIG_fail;
38864 }
38865 {
38866 resultobj = wxPyMake_wxObject(result, (bool)0);
38867 }
38868 return resultobj;
38869 fail:
38870 return NULL;
38871 }
38872
38873
38874 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38875 PyObject *resultobj = 0;
38876 wxMenu *arg1 = (wxMenu *) 0 ;
38877 void *argp1 = 0 ;
38878 int res1 = 0 ;
38879 PyObject *swig_obj[1] ;
38880
38881 if (!args) SWIG_fail;
38882 swig_obj[0] = args;
38883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38884 if (!SWIG_IsOK(res1)) {
38885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38886 }
38887 arg1 = reinterpret_cast< wxMenu * >(argp1);
38888 {
38889 PyThreadState* __tstate = wxPyBeginAllowThreads();
38890 (arg1)->Break();
38891 wxPyEndAllowThreads(__tstate);
38892 if (PyErr_Occurred()) SWIG_fail;
38893 }
38894 resultobj = SWIG_Py_Void();
38895 return resultobj;
38896 fail:
38897 return NULL;
38898 }
38899
38900
38901 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38902 PyObject *resultobj = 0;
38903 wxMenu *arg1 = (wxMenu *) 0 ;
38904 size_t arg2 ;
38905 int arg3 ;
38906 wxString *arg4 = 0 ;
38907 wxString const &arg5_defvalue = wxPyEmptyString ;
38908 wxString *arg5 = (wxString *) &arg5_defvalue ;
38909 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38910 wxMenuItem *result = 0 ;
38911 void *argp1 = 0 ;
38912 int res1 = 0 ;
38913 size_t val2 ;
38914 int ecode2 = 0 ;
38915 int val3 ;
38916 int ecode3 = 0 ;
38917 bool temp4 = false ;
38918 bool temp5 = false ;
38919 int val6 ;
38920 int ecode6 = 0 ;
38921 PyObject * obj0 = 0 ;
38922 PyObject * obj1 = 0 ;
38923 PyObject * obj2 = 0 ;
38924 PyObject * obj3 = 0 ;
38925 PyObject * obj4 = 0 ;
38926 PyObject * obj5 = 0 ;
38927 char * kwnames[] = {
38928 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38929 };
38930
38931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38933 if (!SWIG_IsOK(res1)) {
38934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38935 }
38936 arg1 = reinterpret_cast< wxMenu * >(argp1);
38937 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38938 if (!SWIG_IsOK(ecode2)) {
38939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38940 }
38941 arg2 = static_cast< size_t >(val2);
38942 ecode3 = SWIG_AsVal_int(obj2, &val3);
38943 if (!SWIG_IsOK(ecode3)) {
38944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38945 }
38946 arg3 = static_cast< int >(val3);
38947 {
38948 arg4 = wxString_in_helper(obj3);
38949 if (arg4 == NULL) SWIG_fail;
38950 temp4 = true;
38951 }
38952 if (obj4) {
38953 {
38954 arg5 = wxString_in_helper(obj4);
38955 if (arg5 == NULL) SWIG_fail;
38956 temp5 = true;
38957 }
38958 }
38959 if (obj5) {
38960 ecode6 = SWIG_AsVal_int(obj5, &val6);
38961 if (!SWIG_IsOK(ecode6)) {
38962 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38963 }
38964 arg6 = static_cast< wxItemKind >(val6);
38965 }
38966 {
38967 PyThreadState* __tstate = wxPyBeginAllowThreads();
38968 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38969 wxPyEndAllowThreads(__tstate);
38970 if (PyErr_Occurred()) SWIG_fail;
38971 }
38972 {
38973 resultobj = wxPyMake_wxObject(result, (bool)0);
38974 }
38975 {
38976 if (temp4)
38977 delete arg4;
38978 }
38979 {
38980 if (temp5)
38981 delete arg5;
38982 }
38983 return resultobj;
38984 fail:
38985 {
38986 if (temp4)
38987 delete arg4;
38988 }
38989 {
38990 if (temp5)
38991 delete arg5;
38992 }
38993 return NULL;
38994 }
38995
38996
38997 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38998 PyObject *resultobj = 0;
38999 wxMenu *arg1 = (wxMenu *) 0 ;
39000 size_t arg2 ;
39001 wxMenuItem *result = 0 ;
39002 void *argp1 = 0 ;
39003 int res1 = 0 ;
39004 size_t val2 ;
39005 int ecode2 = 0 ;
39006 PyObject * obj0 = 0 ;
39007 PyObject * obj1 = 0 ;
39008 char * kwnames[] = {
39009 (char *) "self",(char *) "pos", NULL
39010 };
39011
39012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39014 if (!SWIG_IsOK(res1)) {
39015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39016 }
39017 arg1 = reinterpret_cast< wxMenu * >(argp1);
39018 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39019 if (!SWIG_IsOK(ecode2)) {
39020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39021 }
39022 arg2 = static_cast< size_t >(val2);
39023 {
39024 PyThreadState* __tstate = wxPyBeginAllowThreads();
39025 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39026 wxPyEndAllowThreads(__tstate);
39027 if (PyErr_Occurred()) SWIG_fail;
39028 }
39029 {
39030 resultobj = wxPyMake_wxObject(result, (bool)0);
39031 }
39032 return resultobj;
39033 fail:
39034 return NULL;
39035 }
39036
39037
39038 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39039 PyObject *resultobj = 0;
39040 wxMenu *arg1 = (wxMenu *) 0 ;
39041 size_t arg2 ;
39042 int arg3 ;
39043 wxString *arg4 = 0 ;
39044 wxString const &arg5_defvalue = wxPyEmptyString ;
39045 wxString *arg5 = (wxString *) &arg5_defvalue ;
39046 wxMenuItem *result = 0 ;
39047 void *argp1 = 0 ;
39048 int res1 = 0 ;
39049 size_t val2 ;
39050 int ecode2 = 0 ;
39051 int val3 ;
39052 int ecode3 = 0 ;
39053 bool temp4 = false ;
39054 bool temp5 = false ;
39055 PyObject * obj0 = 0 ;
39056 PyObject * obj1 = 0 ;
39057 PyObject * obj2 = 0 ;
39058 PyObject * obj3 = 0 ;
39059 PyObject * obj4 = 0 ;
39060 char * kwnames[] = {
39061 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39062 };
39063
39064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39066 if (!SWIG_IsOK(res1)) {
39067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39068 }
39069 arg1 = reinterpret_cast< wxMenu * >(argp1);
39070 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39071 if (!SWIG_IsOK(ecode2)) {
39072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39073 }
39074 arg2 = static_cast< size_t >(val2);
39075 ecode3 = SWIG_AsVal_int(obj2, &val3);
39076 if (!SWIG_IsOK(ecode3)) {
39077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39078 }
39079 arg3 = static_cast< int >(val3);
39080 {
39081 arg4 = wxString_in_helper(obj3);
39082 if (arg4 == NULL) SWIG_fail;
39083 temp4 = true;
39084 }
39085 if (obj4) {
39086 {
39087 arg5 = wxString_in_helper(obj4);
39088 if (arg5 == NULL) SWIG_fail;
39089 temp5 = true;
39090 }
39091 }
39092 {
39093 PyThreadState* __tstate = wxPyBeginAllowThreads();
39094 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39095 wxPyEndAllowThreads(__tstate);
39096 if (PyErr_Occurred()) SWIG_fail;
39097 }
39098 {
39099 resultobj = wxPyMake_wxObject(result, (bool)0);
39100 }
39101 {
39102 if (temp4)
39103 delete arg4;
39104 }
39105 {
39106 if (temp5)
39107 delete arg5;
39108 }
39109 return resultobj;
39110 fail:
39111 {
39112 if (temp4)
39113 delete arg4;
39114 }
39115 {
39116 if (temp5)
39117 delete arg5;
39118 }
39119 return NULL;
39120 }
39121
39122
39123 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39124 PyObject *resultobj = 0;
39125 wxMenu *arg1 = (wxMenu *) 0 ;
39126 size_t arg2 ;
39127 int arg3 ;
39128 wxString *arg4 = 0 ;
39129 wxString const &arg5_defvalue = wxPyEmptyString ;
39130 wxString *arg5 = (wxString *) &arg5_defvalue ;
39131 wxMenuItem *result = 0 ;
39132 void *argp1 = 0 ;
39133 int res1 = 0 ;
39134 size_t val2 ;
39135 int ecode2 = 0 ;
39136 int val3 ;
39137 int ecode3 = 0 ;
39138 bool temp4 = false ;
39139 bool temp5 = false ;
39140 PyObject * obj0 = 0 ;
39141 PyObject * obj1 = 0 ;
39142 PyObject * obj2 = 0 ;
39143 PyObject * obj3 = 0 ;
39144 PyObject * obj4 = 0 ;
39145 char * kwnames[] = {
39146 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39147 };
39148
39149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39151 if (!SWIG_IsOK(res1)) {
39152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39153 }
39154 arg1 = reinterpret_cast< wxMenu * >(argp1);
39155 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39156 if (!SWIG_IsOK(ecode2)) {
39157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39158 }
39159 arg2 = static_cast< size_t >(val2);
39160 ecode3 = SWIG_AsVal_int(obj2, &val3);
39161 if (!SWIG_IsOK(ecode3)) {
39162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39163 }
39164 arg3 = static_cast< int >(val3);
39165 {
39166 arg4 = wxString_in_helper(obj3);
39167 if (arg4 == NULL) SWIG_fail;
39168 temp4 = true;
39169 }
39170 if (obj4) {
39171 {
39172 arg5 = wxString_in_helper(obj4);
39173 if (arg5 == NULL) SWIG_fail;
39174 temp5 = true;
39175 }
39176 }
39177 {
39178 PyThreadState* __tstate = wxPyBeginAllowThreads();
39179 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39180 wxPyEndAllowThreads(__tstate);
39181 if (PyErr_Occurred()) SWIG_fail;
39182 }
39183 {
39184 resultobj = wxPyMake_wxObject(result, (bool)0);
39185 }
39186 {
39187 if (temp4)
39188 delete arg4;
39189 }
39190 {
39191 if (temp5)
39192 delete arg5;
39193 }
39194 return resultobj;
39195 fail:
39196 {
39197 if (temp4)
39198 delete arg4;
39199 }
39200 {
39201 if (temp5)
39202 delete arg5;
39203 }
39204 return NULL;
39205 }
39206
39207
39208 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39209 PyObject *resultobj = 0;
39210 wxMenu *arg1 = (wxMenu *) 0 ;
39211 size_t arg2 ;
39212 int arg3 ;
39213 wxString *arg4 = 0 ;
39214 wxMenu *arg5 = (wxMenu *) 0 ;
39215 wxString const &arg6_defvalue = wxPyEmptyString ;
39216 wxString *arg6 = (wxString *) &arg6_defvalue ;
39217 wxMenuItem *result = 0 ;
39218 void *argp1 = 0 ;
39219 int res1 = 0 ;
39220 size_t val2 ;
39221 int ecode2 = 0 ;
39222 int val3 ;
39223 int ecode3 = 0 ;
39224 bool temp4 = false ;
39225 void *argp5 = 0 ;
39226 int res5 = 0 ;
39227 bool temp6 = false ;
39228 PyObject * obj0 = 0 ;
39229 PyObject * obj1 = 0 ;
39230 PyObject * obj2 = 0 ;
39231 PyObject * obj3 = 0 ;
39232 PyObject * obj4 = 0 ;
39233 PyObject * obj5 = 0 ;
39234 char * kwnames[] = {
39235 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39236 };
39237
39238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39240 if (!SWIG_IsOK(res1)) {
39241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39242 }
39243 arg1 = reinterpret_cast< wxMenu * >(argp1);
39244 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39245 if (!SWIG_IsOK(ecode2)) {
39246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39247 }
39248 arg2 = static_cast< size_t >(val2);
39249 ecode3 = SWIG_AsVal_int(obj2, &val3);
39250 if (!SWIG_IsOK(ecode3)) {
39251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39252 }
39253 arg3 = static_cast< int >(val3);
39254 {
39255 arg4 = wxString_in_helper(obj3);
39256 if (arg4 == NULL) SWIG_fail;
39257 temp4 = true;
39258 }
39259 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39260 if (!SWIG_IsOK(res5)) {
39261 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39262 }
39263 arg5 = reinterpret_cast< wxMenu * >(argp5);
39264 if (obj5) {
39265 {
39266 arg6 = wxString_in_helper(obj5);
39267 if (arg6 == NULL) SWIG_fail;
39268 temp6 = true;
39269 }
39270 }
39271 {
39272 PyThreadState* __tstate = wxPyBeginAllowThreads();
39273 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39274 wxPyEndAllowThreads(__tstate);
39275 if (PyErr_Occurred()) SWIG_fail;
39276 }
39277 {
39278 resultobj = wxPyMake_wxObject(result, (bool)0);
39279 }
39280 {
39281 if (temp4)
39282 delete arg4;
39283 }
39284 {
39285 if (temp6)
39286 delete arg6;
39287 }
39288 return resultobj;
39289 fail:
39290 {
39291 if (temp4)
39292 delete arg4;
39293 }
39294 {
39295 if (temp6)
39296 delete arg6;
39297 }
39298 return NULL;
39299 }
39300
39301
39302 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39303 PyObject *resultobj = 0;
39304 wxMenu *arg1 = (wxMenu *) 0 ;
39305 int arg2 ;
39306 wxString *arg3 = 0 ;
39307 wxString const &arg4_defvalue = wxPyEmptyString ;
39308 wxString *arg4 = (wxString *) &arg4_defvalue ;
39309 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39310 wxMenuItem *result = 0 ;
39311 void *argp1 = 0 ;
39312 int res1 = 0 ;
39313 int val2 ;
39314 int ecode2 = 0 ;
39315 bool temp3 = false ;
39316 bool temp4 = false ;
39317 int val5 ;
39318 int ecode5 = 0 ;
39319 PyObject * obj0 = 0 ;
39320 PyObject * obj1 = 0 ;
39321 PyObject * obj2 = 0 ;
39322 PyObject * obj3 = 0 ;
39323 PyObject * obj4 = 0 ;
39324 char * kwnames[] = {
39325 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39326 };
39327
39328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39330 if (!SWIG_IsOK(res1)) {
39331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39332 }
39333 arg1 = reinterpret_cast< wxMenu * >(argp1);
39334 ecode2 = SWIG_AsVal_int(obj1, &val2);
39335 if (!SWIG_IsOK(ecode2)) {
39336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39337 }
39338 arg2 = static_cast< int >(val2);
39339 {
39340 arg3 = wxString_in_helper(obj2);
39341 if (arg3 == NULL) SWIG_fail;
39342 temp3 = true;
39343 }
39344 if (obj3) {
39345 {
39346 arg4 = wxString_in_helper(obj3);
39347 if (arg4 == NULL) SWIG_fail;
39348 temp4 = true;
39349 }
39350 }
39351 if (obj4) {
39352 ecode5 = SWIG_AsVal_int(obj4, &val5);
39353 if (!SWIG_IsOK(ecode5)) {
39354 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39355 }
39356 arg5 = static_cast< wxItemKind >(val5);
39357 }
39358 {
39359 PyThreadState* __tstate = wxPyBeginAllowThreads();
39360 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39361 wxPyEndAllowThreads(__tstate);
39362 if (PyErr_Occurred()) SWIG_fail;
39363 }
39364 {
39365 resultobj = wxPyMake_wxObject(result, (bool)0);
39366 }
39367 {
39368 if (temp3)
39369 delete arg3;
39370 }
39371 {
39372 if (temp4)
39373 delete arg4;
39374 }
39375 return resultobj;
39376 fail:
39377 {
39378 if (temp3)
39379 delete arg3;
39380 }
39381 {
39382 if (temp4)
39383 delete arg4;
39384 }
39385 return NULL;
39386 }
39387
39388
39389 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39390 PyObject *resultobj = 0;
39391 wxMenu *arg1 = (wxMenu *) 0 ;
39392 wxMenuItem *result = 0 ;
39393 void *argp1 = 0 ;
39394 int res1 = 0 ;
39395 PyObject *swig_obj[1] ;
39396
39397 if (!args) SWIG_fail;
39398 swig_obj[0] = args;
39399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39400 if (!SWIG_IsOK(res1)) {
39401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39402 }
39403 arg1 = reinterpret_cast< wxMenu * >(argp1);
39404 {
39405 PyThreadState* __tstate = wxPyBeginAllowThreads();
39406 result = (wxMenuItem *)(arg1)->PrependSeparator();
39407 wxPyEndAllowThreads(__tstate);
39408 if (PyErr_Occurred()) SWIG_fail;
39409 }
39410 {
39411 resultobj = wxPyMake_wxObject(result, (bool)0);
39412 }
39413 return resultobj;
39414 fail:
39415 return NULL;
39416 }
39417
39418
39419 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39420 PyObject *resultobj = 0;
39421 wxMenu *arg1 = (wxMenu *) 0 ;
39422 int arg2 ;
39423 wxString *arg3 = 0 ;
39424 wxString const &arg4_defvalue = wxPyEmptyString ;
39425 wxString *arg4 = (wxString *) &arg4_defvalue ;
39426 wxMenuItem *result = 0 ;
39427 void *argp1 = 0 ;
39428 int res1 = 0 ;
39429 int val2 ;
39430 int ecode2 = 0 ;
39431 bool temp3 = false ;
39432 bool temp4 = false ;
39433 PyObject * obj0 = 0 ;
39434 PyObject * obj1 = 0 ;
39435 PyObject * obj2 = 0 ;
39436 PyObject * obj3 = 0 ;
39437 char * kwnames[] = {
39438 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39439 };
39440
39441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39443 if (!SWIG_IsOK(res1)) {
39444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39445 }
39446 arg1 = reinterpret_cast< wxMenu * >(argp1);
39447 ecode2 = SWIG_AsVal_int(obj1, &val2);
39448 if (!SWIG_IsOK(ecode2)) {
39449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39450 }
39451 arg2 = static_cast< int >(val2);
39452 {
39453 arg3 = wxString_in_helper(obj2);
39454 if (arg3 == NULL) SWIG_fail;
39455 temp3 = true;
39456 }
39457 if (obj3) {
39458 {
39459 arg4 = wxString_in_helper(obj3);
39460 if (arg4 == NULL) SWIG_fail;
39461 temp4 = true;
39462 }
39463 }
39464 {
39465 PyThreadState* __tstate = wxPyBeginAllowThreads();
39466 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39467 wxPyEndAllowThreads(__tstate);
39468 if (PyErr_Occurred()) SWIG_fail;
39469 }
39470 {
39471 resultobj = wxPyMake_wxObject(result, (bool)0);
39472 }
39473 {
39474 if (temp3)
39475 delete arg3;
39476 }
39477 {
39478 if (temp4)
39479 delete arg4;
39480 }
39481 return resultobj;
39482 fail:
39483 {
39484 if (temp3)
39485 delete arg3;
39486 }
39487 {
39488 if (temp4)
39489 delete arg4;
39490 }
39491 return NULL;
39492 }
39493
39494
39495 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39496 PyObject *resultobj = 0;
39497 wxMenu *arg1 = (wxMenu *) 0 ;
39498 int arg2 ;
39499 wxString *arg3 = 0 ;
39500 wxString const &arg4_defvalue = wxPyEmptyString ;
39501 wxString *arg4 = (wxString *) &arg4_defvalue ;
39502 wxMenuItem *result = 0 ;
39503 void *argp1 = 0 ;
39504 int res1 = 0 ;
39505 int val2 ;
39506 int ecode2 = 0 ;
39507 bool temp3 = false ;
39508 bool temp4 = false ;
39509 PyObject * obj0 = 0 ;
39510 PyObject * obj1 = 0 ;
39511 PyObject * obj2 = 0 ;
39512 PyObject * obj3 = 0 ;
39513 char * kwnames[] = {
39514 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39515 };
39516
39517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39519 if (!SWIG_IsOK(res1)) {
39520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39521 }
39522 arg1 = reinterpret_cast< wxMenu * >(argp1);
39523 ecode2 = SWIG_AsVal_int(obj1, &val2);
39524 if (!SWIG_IsOK(ecode2)) {
39525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39526 }
39527 arg2 = static_cast< int >(val2);
39528 {
39529 arg3 = wxString_in_helper(obj2);
39530 if (arg3 == NULL) SWIG_fail;
39531 temp3 = true;
39532 }
39533 if (obj3) {
39534 {
39535 arg4 = wxString_in_helper(obj3);
39536 if (arg4 == NULL) SWIG_fail;
39537 temp4 = true;
39538 }
39539 }
39540 {
39541 PyThreadState* __tstate = wxPyBeginAllowThreads();
39542 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39543 wxPyEndAllowThreads(__tstate);
39544 if (PyErr_Occurred()) SWIG_fail;
39545 }
39546 {
39547 resultobj = wxPyMake_wxObject(result, (bool)0);
39548 }
39549 {
39550 if (temp3)
39551 delete arg3;
39552 }
39553 {
39554 if (temp4)
39555 delete arg4;
39556 }
39557 return resultobj;
39558 fail:
39559 {
39560 if (temp3)
39561 delete arg3;
39562 }
39563 {
39564 if (temp4)
39565 delete arg4;
39566 }
39567 return NULL;
39568 }
39569
39570
39571 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39572 PyObject *resultobj = 0;
39573 wxMenu *arg1 = (wxMenu *) 0 ;
39574 int arg2 ;
39575 wxString *arg3 = 0 ;
39576 wxMenu *arg4 = (wxMenu *) 0 ;
39577 wxString const &arg5_defvalue = wxPyEmptyString ;
39578 wxString *arg5 = (wxString *) &arg5_defvalue ;
39579 wxMenuItem *result = 0 ;
39580 void *argp1 = 0 ;
39581 int res1 = 0 ;
39582 int val2 ;
39583 int ecode2 = 0 ;
39584 bool temp3 = false ;
39585 void *argp4 = 0 ;
39586 int res4 = 0 ;
39587 bool temp5 = false ;
39588 PyObject * obj0 = 0 ;
39589 PyObject * obj1 = 0 ;
39590 PyObject * obj2 = 0 ;
39591 PyObject * obj3 = 0 ;
39592 PyObject * obj4 = 0 ;
39593 char * kwnames[] = {
39594 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39595 };
39596
39597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39599 if (!SWIG_IsOK(res1)) {
39600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39601 }
39602 arg1 = reinterpret_cast< wxMenu * >(argp1);
39603 ecode2 = SWIG_AsVal_int(obj1, &val2);
39604 if (!SWIG_IsOK(ecode2)) {
39605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39606 }
39607 arg2 = static_cast< int >(val2);
39608 {
39609 arg3 = wxString_in_helper(obj2);
39610 if (arg3 == NULL) SWIG_fail;
39611 temp3 = true;
39612 }
39613 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39614 if (!SWIG_IsOK(res4)) {
39615 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39616 }
39617 arg4 = reinterpret_cast< wxMenu * >(argp4);
39618 if (obj4) {
39619 {
39620 arg5 = wxString_in_helper(obj4);
39621 if (arg5 == NULL) SWIG_fail;
39622 temp5 = true;
39623 }
39624 }
39625 {
39626 PyThreadState* __tstate = wxPyBeginAllowThreads();
39627 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39628 wxPyEndAllowThreads(__tstate);
39629 if (PyErr_Occurred()) SWIG_fail;
39630 }
39631 {
39632 resultobj = wxPyMake_wxObject(result, (bool)0);
39633 }
39634 {
39635 if (temp3)
39636 delete arg3;
39637 }
39638 {
39639 if (temp5)
39640 delete arg5;
39641 }
39642 return resultobj;
39643 fail:
39644 {
39645 if (temp3)
39646 delete arg3;
39647 }
39648 {
39649 if (temp5)
39650 delete arg5;
39651 }
39652 return NULL;
39653 }
39654
39655
39656 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39657 PyObject *resultobj = 0;
39658 wxMenu *arg1 = (wxMenu *) 0 ;
39659 int arg2 ;
39660 wxMenuItem *result = 0 ;
39661 void *argp1 = 0 ;
39662 int res1 = 0 ;
39663 int val2 ;
39664 int ecode2 = 0 ;
39665 PyObject * obj0 = 0 ;
39666 PyObject * obj1 = 0 ;
39667 char * kwnames[] = {
39668 (char *) "self",(char *) "id", NULL
39669 };
39670
39671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39673 if (!SWIG_IsOK(res1)) {
39674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39675 }
39676 arg1 = reinterpret_cast< wxMenu * >(argp1);
39677 ecode2 = SWIG_AsVal_int(obj1, &val2);
39678 if (!SWIG_IsOK(ecode2)) {
39679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39680 }
39681 arg2 = static_cast< int >(val2);
39682 {
39683 PyThreadState* __tstate = wxPyBeginAllowThreads();
39684 result = (wxMenuItem *)(arg1)->Remove(arg2);
39685 wxPyEndAllowThreads(__tstate);
39686 if (PyErr_Occurred()) SWIG_fail;
39687 }
39688 {
39689 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39690 }
39691 return resultobj;
39692 fail:
39693 return NULL;
39694 }
39695
39696
39697 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39698 PyObject *resultobj = 0;
39699 wxMenu *arg1 = (wxMenu *) 0 ;
39700 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39701 wxMenuItem *result = 0 ;
39702 void *argp1 = 0 ;
39703 int res1 = 0 ;
39704 void *argp2 = 0 ;
39705 int res2 = 0 ;
39706 PyObject * obj0 = 0 ;
39707 PyObject * obj1 = 0 ;
39708 char * kwnames[] = {
39709 (char *) "self",(char *) "item", NULL
39710 };
39711
39712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39714 if (!SWIG_IsOK(res1)) {
39715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39716 }
39717 arg1 = reinterpret_cast< wxMenu * >(argp1);
39718 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39719 if (!SWIG_IsOK(res2)) {
39720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39721 }
39722 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39723 {
39724 PyThreadState* __tstate = wxPyBeginAllowThreads();
39725 result = (wxMenuItem *)(arg1)->Remove(arg2);
39726 wxPyEndAllowThreads(__tstate);
39727 if (PyErr_Occurred()) SWIG_fail;
39728 }
39729 {
39730 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39731 }
39732 return resultobj;
39733 fail:
39734 return NULL;
39735 }
39736
39737
39738 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39739 PyObject *resultobj = 0;
39740 wxMenu *arg1 = (wxMenu *) 0 ;
39741 int arg2 ;
39742 bool result;
39743 void *argp1 = 0 ;
39744 int res1 = 0 ;
39745 int val2 ;
39746 int ecode2 = 0 ;
39747 PyObject * obj0 = 0 ;
39748 PyObject * obj1 = 0 ;
39749 char * kwnames[] = {
39750 (char *) "self",(char *) "id", NULL
39751 };
39752
39753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39755 if (!SWIG_IsOK(res1)) {
39756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39757 }
39758 arg1 = reinterpret_cast< wxMenu * >(argp1);
39759 ecode2 = SWIG_AsVal_int(obj1, &val2);
39760 if (!SWIG_IsOK(ecode2)) {
39761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39762 }
39763 arg2 = static_cast< int >(val2);
39764 {
39765 PyThreadState* __tstate = wxPyBeginAllowThreads();
39766 result = (bool)(arg1)->Delete(arg2);
39767 wxPyEndAllowThreads(__tstate);
39768 if (PyErr_Occurred()) SWIG_fail;
39769 }
39770 {
39771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39772 }
39773 return resultobj;
39774 fail:
39775 return NULL;
39776 }
39777
39778
39779 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39780 PyObject *resultobj = 0;
39781 wxMenu *arg1 = (wxMenu *) 0 ;
39782 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39783 bool result;
39784 void *argp1 = 0 ;
39785 int res1 = 0 ;
39786 void *argp2 = 0 ;
39787 int res2 = 0 ;
39788 PyObject * obj0 = 0 ;
39789 PyObject * obj1 = 0 ;
39790 char * kwnames[] = {
39791 (char *) "self",(char *) "item", NULL
39792 };
39793
39794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39796 if (!SWIG_IsOK(res1)) {
39797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39798 }
39799 arg1 = reinterpret_cast< wxMenu * >(argp1);
39800 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39801 if (!SWIG_IsOK(res2)) {
39802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39803 }
39804 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39805 {
39806 PyThreadState* __tstate = wxPyBeginAllowThreads();
39807 result = (bool)(arg1)->Delete(arg2);
39808 wxPyEndAllowThreads(__tstate);
39809 if (PyErr_Occurred()) SWIG_fail;
39810 }
39811 {
39812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39813 }
39814 return resultobj;
39815 fail:
39816 return NULL;
39817 }
39818
39819
39820 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39821 PyObject *resultobj = 0;
39822 wxMenu *arg1 = (wxMenu *) 0 ;
39823 void *argp1 = 0 ;
39824 int res1 = 0 ;
39825 PyObject *swig_obj[1] ;
39826
39827 if (!args) SWIG_fail;
39828 swig_obj[0] = args;
39829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39830 if (!SWIG_IsOK(res1)) {
39831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39832 }
39833 arg1 = reinterpret_cast< wxMenu * >(argp1);
39834 {
39835 PyThreadState* __tstate = wxPyBeginAllowThreads();
39836 wxMenu_Destroy(arg1);
39837 wxPyEndAllowThreads(__tstate);
39838 if (PyErr_Occurred()) SWIG_fail;
39839 }
39840 resultobj = SWIG_Py_Void();
39841 return resultobj;
39842 fail:
39843 return NULL;
39844 }
39845
39846
39847 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39848 PyObject *resultobj = 0;
39849 wxMenu *arg1 = (wxMenu *) 0 ;
39850 int arg2 ;
39851 bool result;
39852 void *argp1 = 0 ;
39853 int res1 = 0 ;
39854 int val2 ;
39855 int ecode2 = 0 ;
39856 PyObject * obj0 = 0 ;
39857 PyObject * obj1 = 0 ;
39858 char * kwnames[] = {
39859 (char *) "self",(char *) "id", NULL
39860 };
39861
39862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39864 if (!SWIG_IsOK(res1)) {
39865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39866 }
39867 arg1 = reinterpret_cast< wxMenu * >(argp1);
39868 ecode2 = SWIG_AsVal_int(obj1, &val2);
39869 if (!SWIG_IsOK(ecode2)) {
39870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39871 }
39872 arg2 = static_cast< int >(val2);
39873 {
39874 PyThreadState* __tstate = wxPyBeginAllowThreads();
39875 result = (bool)(arg1)->Destroy(arg2);
39876 wxPyEndAllowThreads(__tstate);
39877 if (PyErr_Occurred()) SWIG_fail;
39878 }
39879 {
39880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39881 }
39882 return resultobj;
39883 fail:
39884 return NULL;
39885 }
39886
39887
39888 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39889 PyObject *resultobj = 0;
39890 wxMenu *arg1 = (wxMenu *) 0 ;
39891 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39892 bool result;
39893 void *argp1 = 0 ;
39894 int res1 = 0 ;
39895 void *argp2 = 0 ;
39896 int res2 = 0 ;
39897 PyObject * obj0 = 0 ;
39898 PyObject * obj1 = 0 ;
39899 char * kwnames[] = {
39900 (char *) "self",(char *) "item", NULL
39901 };
39902
39903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39905 if (!SWIG_IsOK(res1)) {
39906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39907 }
39908 arg1 = reinterpret_cast< wxMenu * >(argp1);
39909 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39910 if (!SWIG_IsOK(res2)) {
39911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39912 }
39913 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39914 {
39915 PyThreadState* __tstate = wxPyBeginAllowThreads();
39916 result = (bool)(arg1)->Destroy(arg2);
39917 wxPyEndAllowThreads(__tstate);
39918 if (PyErr_Occurred()) SWIG_fail;
39919 }
39920 {
39921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39922 }
39923 return resultobj;
39924 fail:
39925 return NULL;
39926 }
39927
39928
39929 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39930 PyObject *resultobj = 0;
39931 wxMenu *arg1 = (wxMenu *) 0 ;
39932 size_t result;
39933 void *argp1 = 0 ;
39934 int res1 = 0 ;
39935 PyObject *swig_obj[1] ;
39936
39937 if (!args) SWIG_fail;
39938 swig_obj[0] = args;
39939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39940 if (!SWIG_IsOK(res1)) {
39941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39942 }
39943 arg1 = reinterpret_cast< wxMenu * >(argp1);
39944 {
39945 PyThreadState* __tstate = wxPyBeginAllowThreads();
39946 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39947 wxPyEndAllowThreads(__tstate);
39948 if (PyErr_Occurred()) SWIG_fail;
39949 }
39950 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39951 return resultobj;
39952 fail:
39953 return NULL;
39954 }
39955
39956
39957 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39958 PyObject *resultobj = 0;
39959 wxMenu *arg1 = (wxMenu *) 0 ;
39960 PyObject *result = 0 ;
39961 void *argp1 = 0 ;
39962 int res1 = 0 ;
39963 PyObject *swig_obj[1] ;
39964
39965 if (!args) SWIG_fail;
39966 swig_obj[0] = args;
39967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39968 if (!SWIG_IsOK(res1)) {
39969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39970 }
39971 arg1 = reinterpret_cast< wxMenu * >(argp1);
39972 {
39973 PyThreadState* __tstate = wxPyBeginAllowThreads();
39974 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39975 wxPyEndAllowThreads(__tstate);
39976 if (PyErr_Occurred()) SWIG_fail;
39977 }
39978 resultobj = result;
39979 return resultobj;
39980 fail:
39981 return NULL;
39982 }
39983
39984
39985 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39986 PyObject *resultobj = 0;
39987 wxMenu *arg1 = (wxMenu *) 0 ;
39988 wxString *arg2 = 0 ;
39989 int result;
39990 void *argp1 = 0 ;
39991 int res1 = 0 ;
39992 bool temp2 = false ;
39993 PyObject * obj0 = 0 ;
39994 PyObject * obj1 = 0 ;
39995 char * kwnames[] = {
39996 (char *) "self",(char *) "item", NULL
39997 };
39998
39999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40001 if (!SWIG_IsOK(res1)) {
40002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40003 }
40004 arg1 = reinterpret_cast< wxMenu * >(argp1);
40005 {
40006 arg2 = wxString_in_helper(obj1);
40007 if (arg2 == NULL) SWIG_fail;
40008 temp2 = true;
40009 }
40010 {
40011 PyThreadState* __tstate = wxPyBeginAllowThreads();
40012 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40013 wxPyEndAllowThreads(__tstate);
40014 if (PyErr_Occurred()) SWIG_fail;
40015 }
40016 resultobj = SWIG_From_int(static_cast< int >(result));
40017 {
40018 if (temp2)
40019 delete arg2;
40020 }
40021 return resultobj;
40022 fail:
40023 {
40024 if (temp2)
40025 delete arg2;
40026 }
40027 return NULL;
40028 }
40029
40030
40031 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40032 PyObject *resultobj = 0;
40033 wxMenu *arg1 = (wxMenu *) 0 ;
40034 int arg2 ;
40035 wxMenuItem *result = 0 ;
40036 void *argp1 = 0 ;
40037 int res1 = 0 ;
40038 int val2 ;
40039 int ecode2 = 0 ;
40040 PyObject * obj0 = 0 ;
40041 PyObject * obj1 = 0 ;
40042 char * kwnames[] = {
40043 (char *) "self",(char *) "id", NULL
40044 };
40045
40046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40048 if (!SWIG_IsOK(res1)) {
40049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40050 }
40051 arg1 = reinterpret_cast< wxMenu * >(argp1);
40052 ecode2 = SWIG_AsVal_int(obj1, &val2);
40053 if (!SWIG_IsOK(ecode2)) {
40054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40055 }
40056 arg2 = static_cast< int >(val2);
40057 {
40058 PyThreadState* __tstate = wxPyBeginAllowThreads();
40059 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40060 wxPyEndAllowThreads(__tstate);
40061 if (PyErr_Occurred()) SWIG_fail;
40062 }
40063 {
40064 resultobj = wxPyMake_wxObject(result, (bool)0);
40065 }
40066 return resultobj;
40067 fail:
40068 return NULL;
40069 }
40070
40071
40072 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40073 PyObject *resultobj = 0;
40074 wxMenu *arg1 = (wxMenu *) 0 ;
40075 size_t arg2 ;
40076 wxMenuItem *result = 0 ;
40077 void *argp1 = 0 ;
40078 int res1 = 0 ;
40079 size_t val2 ;
40080 int ecode2 = 0 ;
40081 PyObject * obj0 = 0 ;
40082 PyObject * obj1 = 0 ;
40083 char * kwnames[] = {
40084 (char *) "self",(char *) "position", NULL
40085 };
40086
40087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40089 if (!SWIG_IsOK(res1)) {
40090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40091 }
40092 arg1 = reinterpret_cast< wxMenu * >(argp1);
40093 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40094 if (!SWIG_IsOK(ecode2)) {
40095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40096 }
40097 arg2 = static_cast< size_t >(val2);
40098 {
40099 PyThreadState* __tstate = wxPyBeginAllowThreads();
40100 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40101 wxPyEndAllowThreads(__tstate);
40102 if (PyErr_Occurred()) SWIG_fail;
40103 }
40104 {
40105 resultobj = wxPyMake_wxObject(result, (bool)0);
40106 }
40107 return resultobj;
40108 fail:
40109 return NULL;
40110 }
40111
40112
40113 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40114 PyObject *resultobj = 0;
40115 wxMenu *arg1 = (wxMenu *) 0 ;
40116 int arg2 ;
40117 bool arg3 ;
40118 void *argp1 = 0 ;
40119 int res1 = 0 ;
40120 int val2 ;
40121 int ecode2 = 0 ;
40122 bool val3 ;
40123 int ecode3 = 0 ;
40124 PyObject * obj0 = 0 ;
40125 PyObject * obj1 = 0 ;
40126 PyObject * obj2 = 0 ;
40127 char * kwnames[] = {
40128 (char *) "self",(char *) "id",(char *) "enable", NULL
40129 };
40130
40131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40133 if (!SWIG_IsOK(res1)) {
40134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40135 }
40136 arg1 = reinterpret_cast< wxMenu * >(argp1);
40137 ecode2 = SWIG_AsVal_int(obj1, &val2);
40138 if (!SWIG_IsOK(ecode2)) {
40139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40140 }
40141 arg2 = static_cast< int >(val2);
40142 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40143 if (!SWIG_IsOK(ecode3)) {
40144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40145 }
40146 arg3 = static_cast< bool >(val3);
40147 {
40148 PyThreadState* __tstate = wxPyBeginAllowThreads();
40149 (arg1)->Enable(arg2,arg3);
40150 wxPyEndAllowThreads(__tstate);
40151 if (PyErr_Occurred()) SWIG_fail;
40152 }
40153 resultobj = SWIG_Py_Void();
40154 return resultobj;
40155 fail:
40156 return NULL;
40157 }
40158
40159
40160 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40161 PyObject *resultobj = 0;
40162 wxMenu *arg1 = (wxMenu *) 0 ;
40163 int arg2 ;
40164 bool result;
40165 void *argp1 = 0 ;
40166 int res1 = 0 ;
40167 int val2 ;
40168 int ecode2 = 0 ;
40169 PyObject * obj0 = 0 ;
40170 PyObject * obj1 = 0 ;
40171 char * kwnames[] = {
40172 (char *) "self",(char *) "id", NULL
40173 };
40174
40175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40177 if (!SWIG_IsOK(res1)) {
40178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40179 }
40180 arg1 = reinterpret_cast< wxMenu * >(argp1);
40181 ecode2 = SWIG_AsVal_int(obj1, &val2);
40182 if (!SWIG_IsOK(ecode2)) {
40183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40184 }
40185 arg2 = static_cast< int >(val2);
40186 {
40187 PyThreadState* __tstate = wxPyBeginAllowThreads();
40188 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40189 wxPyEndAllowThreads(__tstate);
40190 if (PyErr_Occurred()) SWIG_fail;
40191 }
40192 {
40193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40194 }
40195 return resultobj;
40196 fail:
40197 return NULL;
40198 }
40199
40200
40201 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40202 PyObject *resultobj = 0;
40203 wxMenu *arg1 = (wxMenu *) 0 ;
40204 int arg2 ;
40205 bool arg3 ;
40206 void *argp1 = 0 ;
40207 int res1 = 0 ;
40208 int val2 ;
40209 int ecode2 = 0 ;
40210 bool val3 ;
40211 int ecode3 = 0 ;
40212 PyObject * obj0 = 0 ;
40213 PyObject * obj1 = 0 ;
40214 PyObject * obj2 = 0 ;
40215 char * kwnames[] = {
40216 (char *) "self",(char *) "id",(char *) "check", NULL
40217 };
40218
40219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40221 if (!SWIG_IsOK(res1)) {
40222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40223 }
40224 arg1 = reinterpret_cast< wxMenu * >(argp1);
40225 ecode2 = SWIG_AsVal_int(obj1, &val2);
40226 if (!SWIG_IsOK(ecode2)) {
40227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40228 }
40229 arg2 = static_cast< int >(val2);
40230 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40231 if (!SWIG_IsOK(ecode3)) {
40232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40233 }
40234 arg3 = static_cast< bool >(val3);
40235 {
40236 PyThreadState* __tstate = wxPyBeginAllowThreads();
40237 (arg1)->Check(arg2,arg3);
40238 wxPyEndAllowThreads(__tstate);
40239 if (PyErr_Occurred()) SWIG_fail;
40240 }
40241 resultobj = SWIG_Py_Void();
40242 return resultobj;
40243 fail:
40244 return NULL;
40245 }
40246
40247
40248 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40249 PyObject *resultobj = 0;
40250 wxMenu *arg1 = (wxMenu *) 0 ;
40251 int arg2 ;
40252 bool result;
40253 void *argp1 = 0 ;
40254 int res1 = 0 ;
40255 int val2 ;
40256 int ecode2 = 0 ;
40257 PyObject * obj0 = 0 ;
40258 PyObject * obj1 = 0 ;
40259 char * kwnames[] = {
40260 (char *) "self",(char *) "id", NULL
40261 };
40262
40263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40265 if (!SWIG_IsOK(res1)) {
40266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40267 }
40268 arg1 = reinterpret_cast< wxMenu * >(argp1);
40269 ecode2 = SWIG_AsVal_int(obj1, &val2);
40270 if (!SWIG_IsOK(ecode2)) {
40271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40272 }
40273 arg2 = static_cast< int >(val2);
40274 {
40275 PyThreadState* __tstate = wxPyBeginAllowThreads();
40276 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40277 wxPyEndAllowThreads(__tstate);
40278 if (PyErr_Occurred()) SWIG_fail;
40279 }
40280 {
40281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40282 }
40283 return resultobj;
40284 fail:
40285 return NULL;
40286 }
40287
40288
40289 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40290 PyObject *resultobj = 0;
40291 wxMenu *arg1 = (wxMenu *) 0 ;
40292 int arg2 ;
40293 wxString *arg3 = 0 ;
40294 void *argp1 = 0 ;
40295 int res1 = 0 ;
40296 int val2 ;
40297 int ecode2 = 0 ;
40298 bool temp3 = false ;
40299 PyObject * obj0 = 0 ;
40300 PyObject * obj1 = 0 ;
40301 PyObject * obj2 = 0 ;
40302 char * kwnames[] = {
40303 (char *) "self",(char *) "id",(char *) "label", NULL
40304 };
40305
40306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40308 if (!SWIG_IsOK(res1)) {
40309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40310 }
40311 arg1 = reinterpret_cast< wxMenu * >(argp1);
40312 ecode2 = SWIG_AsVal_int(obj1, &val2);
40313 if (!SWIG_IsOK(ecode2)) {
40314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40315 }
40316 arg2 = static_cast< int >(val2);
40317 {
40318 arg3 = wxString_in_helper(obj2);
40319 if (arg3 == NULL) SWIG_fail;
40320 temp3 = true;
40321 }
40322 {
40323 PyThreadState* __tstate = wxPyBeginAllowThreads();
40324 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40325 wxPyEndAllowThreads(__tstate);
40326 if (PyErr_Occurred()) SWIG_fail;
40327 }
40328 resultobj = SWIG_Py_Void();
40329 {
40330 if (temp3)
40331 delete arg3;
40332 }
40333 return resultobj;
40334 fail:
40335 {
40336 if (temp3)
40337 delete arg3;
40338 }
40339 return NULL;
40340 }
40341
40342
40343 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40344 PyObject *resultobj = 0;
40345 wxMenu *arg1 = (wxMenu *) 0 ;
40346 int arg2 ;
40347 wxString result;
40348 void *argp1 = 0 ;
40349 int res1 = 0 ;
40350 int val2 ;
40351 int ecode2 = 0 ;
40352 PyObject * obj0 = 0 ;
40353 PyObject * obj1 = 0 ;
40354 char * kwnames[] = {
40355 (char *) "self",(char *) "id", NULL
40356 };
40357
40358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40360 if (!SWIG_IsOK(res1)) {
40361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40362 }
40363 arg1 = reinterpret_cast< wxMenu * >(argp1);
40364 ecode2 = SWIG_AsVal_int(obj1, &val2);
40365 if (!SWIG_IsOK(ecode2)) {
40366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40367 }
40368 arg2 = static_cast< int >(val2);
40369 {
40370 PyThreadState* __tstate = wxPyBeginAllowThreads();
40371 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40372 wxPyEndAllowThreads(__tstate);
40373 if (PyErr_Occurred()) SWIG_fail;
40374 }
40375 {
40376 #if wxUSE_UNICODE
40377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40378 #else
40379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40380 #endif
40381 }
40382 return resultobj;
40383 fail:
40384 return NULL;
40385 }
40386
40387
40388 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40389 PyObject *resultobj = 0;
40390 wxMenu *arg1 = (wxMenu *) 0 ;
40391 int arg2 ;
40392 wxString *arg3 = 0 ;
40393 void *argp1 = 0 ;
40394 int res1 = 0 ;
40395 int val2 ;
40396 int ecode2 = 0 ;
40397 bool temp3 = false ;
40398 PyObject * obj0 = 0 ;
40399 PyObject * obj1 = 0 ;
40400 PyObject * obj2 = 0 ;
40401 char * kwnames[] = {
40402 (char *) "self",(char *) "id",(char *) "helpString", NULL
40403 };
40404
40405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40407 if (!SWIG_IsOK(res1)) {
40408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40409 }
40410 arg1 = reinterpret_cast< wxMenu * >(argp1);
40411 ecode2 = SWIG_AsVal_int(obj1, &val2);
40412 if (!SWIG_IsOK(ecode2)) {
40413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40414 }
40415 arg2 = static_cast< int >(val2);
40416 {
40417 arg3 = wxString_in_helper(obj2);
40418 if (arg3 == NULL) SWIG_fail;
40419 temp3 = true;
40420 }
40421 {
40422 PyThreadState* __tstate = wxPyBeginAllowThreads();
40423 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40424 wxPyEndAllowThreads(__tstate);
40425 if (PyErr_Occurred()) SWIG_fail;
40426 }
40427 resultobj = SWIG_Py_Void();
40428 {
40429 if (temp3)
40430 delete arg3;
40431 }
40432 return resultobj;
40433 fail:
40434 {
40435 if (temp3)
40436 delete arg3;
40437 }
40438 return NULL;
40439 }
40440
40441
40442 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40443 PyObject *resultobj = 0;
40444 wxMenu *arg1 = (wxMenu *) 0 ;
40445 int arg2 ;
40446 wxString result;
40447 void *argp1 = 0 ;
40448 int res1 = 0 ;
40449 int val2 ;
40450 int ecode2 = 0 ;
40451 PyObject * obj0 = 0 ;
40452 PyObject * obj1 = 0 ;
40453 char * kwnames[] = {
40454 (char *) "self",(char *) "id", NULL
40455 };
40456
40457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40459 if (!SWIG_IsOK(res1)) {
40460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40461 }
40462 arg1 = reinterpret_cast< wxMenu * >(argp1);
40463 ecode2 = SWIG_AsVal_int(obj1, &val2);
40464 if (!SWIG_IsOK(ecode2)) {
40465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40466 }
40467 arg2 = static_cast< int >(val2);
40468 {
40469 PyThreadState* __tstate = wxPyBeginAllowThreads();
40470 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40471 wxPyEndAllowThreads(__tstate);
40472 if (PyErr_Occurred()) SWIG_fail;
40473 }
40474 {
40475 #if wxUSE_UNICODE
40476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40477 #else
40478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40479 #endif
40480 }
40481 return resultobj;
40482 fail:
40483 return NULL;
40484 }
40485
40486
40487 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40488 PyObject *resultobj = 0;
40489 wxMenu *arg1 = (wxMenu *) 0 ;
40490 wxString *arg2 = 0 ;
40491 void *argp1 = 0 ;
40492 int res1 = 0 ;
40493 bool temp2 = false ;
40494 PyObject * obj0 = 0 ;
40495 PyObject * obj1 = 0 ;
40496 char * kwnames[] = {
40497 (char *) "self",(char *) "title", NULL
40498 };
40499
40500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40502 if (!SWIG_IsOK(res1)) {
40503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40504 }
40505 arg1 = reinterpret_cast< wxMenu * >(argp1);
40506 {
40507 arg2 = wxString_in_helper(obj1);
40508 if (arg2 == NULL) SWIG_fail;
40509 temp2 = true;
40510 }
40511 {
40512 PyThreadState* __tstate = wxPyBeginAllowThreads();
40513 (arg1)->SetTitle((wxString const &)*arg2);
40514 wxPyEndAllowThreads(__tstate);
40515 if (PyErr_Occurred()) SWIG_fail;
40516 }
40517 resultobj = SWIG_Py_Void();
40518 {
40519 if (temp2)
40520 delete arg2;
40521 }
40522 return resultobj;
40523 fail:
40524 {
40525 if (temp2)
40526 delete arg2;
40527 }
40528 return NULL;
40529 }
40530
40531
40532 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40533 PyObject *resultobj = 0;
40534 wxMenu *arg1 = (wxMenu *) 0 ;
40535 wxString result;
40536 void *argp1 = 0 ;
40537 int res1 = 0 ;
40538 PyObject *swig_obj[1] ;
40539
40540 if (!args) SWIG_fail;
40541 swig_obj[0] = args;
40542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40543 if (!SWIG_IsOK(res1)) {
40544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40545 }
40546 arg1 = reinterpret_cast< wxMenu * >(argp1);
40547 {
40548 PyThreadState* __tstate = wxPyBeginAllowThreads();
40549 result = ((wxMenu const *)arg1)->GetTitle();
40550 wxPyEndAllowThreads(__tstate);
40551 if (PyErr_Occurred()) SWIG_fail;
40552 }
40553 {
40554 #if wxUSE_UNICODE
40555 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40556 #else
40557 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40558 #endif
40559 }
40560 return resultobj;
40561 fail:
40562 return NULL;
40563 }
40564
40565
40566 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40567 PyObject *resultobj = 0;
40568 wxMenu *arg1 = (wxMenu *) 0 ;
40569 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40570 void *argp1 = 0 ;
40571 int res1 = 0 ;
40572 void *argp2 = 0 ;
40573 int res2 = 0 ;
40574 PyObject * obj0 = 0 ;
40575 PyObject * obj1 = 0 ;
40576 char * kwnames[] = {
40577 (char *) "self",(char *) "handler", NULL
40578 };
40579
40580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40582 if (!SWIG_IsOK(res1)) {
40583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40584 }
40585 arg1 = reinterpret_cast< wxMenu * >(argp1);
40586 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40587 if (!SWIG_IsOK(res2)) {
40588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40589 }
40590 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40591 {
40592 PyThreadState* __tstate = wxPyBeginAllowThreads();
40593 (arg1)->SetEventHandler(arg2);
40594 wxPyEndAllowThreads(__tstate);
40595 if (PyErr_Occurred()) SWIG_fail;
40596 }
40597 resultobj = SWIG_Py_Void();
40598 return resultobj;
40599 fail:
40600 return NULL;
40601 }
40602
40603
40604 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40605 PyObject *resultobj = 0;
40606 wxMenu *arg1 = (wxMenu *) 0 ;
40607 wxEvtHandler *result = 0 ;
40608 void *argp1 = 0 ;
40609 int res1 = 0 ;
40610 PyObject *swig_obj[1] ;
40611
40612 if (!args) SWIG_fail;
40613 swig_obj[0] = args;
40614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40615 if (!SWIG_IsOK(res1)) {
40616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40617 }
40618 arg1 = reinterpret_cast< wxMenu * >(argp1);
40619 {
40620 PyThreadState* __tstate = wxPyBeginAllowThreads();
40621 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40622 wxPyEndAllowThreads(__tstate);
40623 if (PyErr_Occurred()) SWIG_fail;
40624 }
40625 {
40626 resultobj = wxPyMake_wxObject(result, 0);
40627 }
40628 return resultobj;
40629 fail:
40630 return NULL;
40631 }
40632
40633
40634 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40635 PyObject *resultobj = 0;
40636 wxMenu *arg1 = (wxMenu *) 0 ;
40637 wxWindow *arg2 = (wxWindow *) 0 ;
40638 void *argp1 = 0 ;
40639 int res1 = 0 ;
40640 void *argp2 = 0 ;
40641 int res2 = 0 ;
40642 PyObject * obj0 = 0 ;
40643 PyObject * obj1 = 0 ;
40644 char * kwnames[] = {
40645 (char *) "self",(char *) "win", NULL
40646 };
40647
40648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40650 if (!SWIG_IsOK(res1)) {
40651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40652 }
40653 arg1 = reinterpret_cast< wxMenu * >(argp1);
40654 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40655 if (!SWIG_IsOK(res2)) {
40656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40657 }
40658 arg2 = reinterpret_cast< wxWindow * >(argp2);
40659 {
40660 PyThreadState* __tstate = wxPyBeginAllowThreads();
40661 (arg1)->SetInvokingWindow(arg2);
40662 wxPyEndAllowThreads(__tstate);
40663 if (PyErr_Occurred()) SWIG_fail;
40664 }
40665 resultobj = SWIG_Py_Void();
40666 return resultobj;
40667 fail:
40668 return NULL;
40669 }
40670
40671
40672 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40673 PyObject *resultobj = 0;
40674 wxMenu *arg1 = (wxMenu *) 0 ;
40675 wxWindow *result = 0 ;
40676 void *argp1 = 0 ;
40677 int res1 = 0 ;
40678 PyObject *swig_obj[1] ;
40679
40680 if (!args) SWIG_fail;
40681 swig_obj[0] = args;
40682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40683 if (!SWIG_IsOK(res1)) {
40684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40685 }
40686 arg1 = reinterpret_cast< wxMenu * >(argp1);
40687 {
40688 PyThreadState* __tstate = wxPyBeginAllowThreads();
40689 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40690 wxPyEndAllowThreads(__tstate);
40691 if (PyErr_Occurred()) SWIG_fail;
40692 }
40693 {
40694 resultobj = wxPyMake_wxObject(result, 0);
40695 }
40696 return resultobj;
40697 fail:
40698 return NULL;
40699 }
40700
40701
40702 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40703 PyObject *resultobj = 0;
40704 wxMenu *arg1 = (wxMenu *) 0 ;
40705 long result;
40706 void *argp1 = 0 ;
40707 int res1 = 0 ;
40708 PyObject *swig_obj[1] ;
40709
40710 if (!args) SWIG_fail;
40711 swig_obj[0] = args;
40712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40713 if (!SWIG_IsOK(res1)) {
40714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40715 }
40716 arg1 = reinterpret_cast< wxMenu * >(argp1);
40717 {
40718 PyThreadState* __tstate = wxPyBeginAllowThreads();
40719 result = (long)((wxMenu const *)arg1)->GetStyle();
40720 wxPyEndAllowThreads(__tstate);
40721 if (PyErr_Occurred()) SWIG_fail;
40722 }
40723 resultobj = SWIG_From_long(static_cast< long >(result));
40724 return resultobj;
40725 fail:
40726 return NULL;
40727 }
40728
40729
40730 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40731 PyObject *resultobj = 0;
40732 wxMenu *arg1 = (wxMenu *) 0 ;
40733 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40734 void *argp1 = 0 ;
40735 int res1 = 0 ;
40736 void *argp2 = 0 ;
40737 int res2 = 0 ;
40738 PyObject * obj0 = 0 ;
40739 PyObject * obj1 = 0 ;
40740 char * kwnames[] = {
40741 (char *) "self",(char *) "source", NULL
40742 };
40743
40744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40746 if (!SWIG_IsOK(res1)) {
40747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40748 }
40749 arg1 = reinterpret_cast< wxMenu * >(argp1);
40750 if (obj1) {
40751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40752 if (!SWIG_IsOK(res2)) {
40753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40754 }
40755 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40756 }
40757 {
40758 PyThreadState* __tstate = wxPyBeginAllowThreads();
40759 (arg1)->UpdateUI(arg2);
40760 wxPyEndAllowThreads(__tstate);
40761 if (PyErr_Occurred()) SWIG_fail;
40762 }
40763 resultobj = SWIG_Py_Void();
40764 return resultobj;
40765 fail:
40766 return NULL;
40767 }
40768
40769
40770 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40771 PyObject *resultobj = 0;
40772 wxMenu *arg1 = (wxMenu *) 0 ;
40773 wxMenuBar *result = 0 ;
40774 void *argp1 = 0 ;
40775 int res1 = 0 ;
40776 PyObject *swig_obj[1] ;
40777
40778 if (!args) SWIG_fail;
40779 swig_obj[0] = args;
40780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40781 if (!SWIG_IsOK(res1)) {
40782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40783 }
40784 arg1 = reinterpret_cast< wxMenu * >(argp1);
40785 {
40786 PyThreadState* __tstate = wxPyBeginAllowThreads();
40787 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40788 wxPyEndAllowThreads(__tstate);
40789 if (PyErr_Occurred()) SWIG_fail;
40790 }
40791 {
40792 resultobj = wxPyMake_wxObject(result, (bool)0);
40793 }
40794 return resultobj;
40795 fail:
40796 return NULL;
40797 }
40798
40799
40800 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40801 PyObject *resultobj = 0;
40802 wxMenu *arg1 = (wxMenu *) 0 ;
40803 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40804 void *argp1 = 0 ;
40805 int res1 = 0 ;
40806 void *argp2 = 0 ;
40807 int res2 = 0 ;
40808 PyObject * obj0 = 0 ;
40809 PyObject * obj1 = 0 ;
40810 char * kwnames[] = {
40811 (char *) "self",(char *) "menubar", NULL
40812 };
40813
40814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40816 if (!SWIG_IsOK(res1)) {
40817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40818 }
40819 arg1 = reinterpret_cast< wxMenu * >(argp1);
40820 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40821 if (!SWIG_IsOK(res2)) {
40822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40823 }
40824 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40825 {
40826 PyThreadState* __tstate = wxPyBeginAllowThreads();
40827 (arg1)->Attach(arg2);
40828 wxPyEndAllowThreads(__tstate);
40829 if (PyErr_Occurred()) SWIG_fail;
40830 }
40831 resultobj = SWIG_Py_Void();
40832 return resultobj;
40833 fail:
40834 return NULL;
40835 }
40836
40837
40838 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40839 PyObject *resultobj = 0;
40840 wxMenu *arg1 = (wxMenu *) 0 ;
40841 void *argp1 = 0 ;
40842 int res1 = 0 ;
40843 PyObject *swig_obj[1] ;
40844
40845 if (!args) SWIG_fail;
40846 swig_obj[0] = args;
40847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40848 if (!SWIG_IsOK(res1)) {
40849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40850 }
40851 arg1 = reinterpret_cast< wxMenu * >(argp1);
40852 {
40853 PyThreadState* __tstate = wxPyBeginAllowThreads();
40854 (arg1)->Detach();
40855 wxPyEndAllowThreads(__tstate);
40856 if (PyErr_Occurred()) SWIG_fail;
40857 }
40858 resultobj = SWIG_Py_Void();
40859 return resultobj;
40860 fail:
40861 return NULL;
40862 }
40863
40864
40865 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40866 PyObject *resultobj = 0;
40867 wxMenu *arg1 = (wxMenu *) 0 ;
40868 bool result;
40869 void *argp1 = 0 ;
40870 int res1 = 0 ;
40871 PyObject *swig_obj[1] ;
40872
40873 if (!args) SWIG_fail;
40874 swig_obj[0] = args;
40875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40876 if (!SWIG_IsOK(res1)) {
40877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40878 }
40879 arg1 = reinterpret_cast< wxMenu * >(argp1);
40880 {
40881 PyThreadState* __tstate = wxPyBeginAllowThreads();
40882 result = (bool)((wxMenu const *)arg1)->IsAttached();
40883 wxPyEndAllowThreads(__tstate);
40884 if (PyErr_Occurred()) SWIG_fail;
40885 }
40886 {
40887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40888 }
40889 return resultobj;
40890 fail:
40891 return NULL;
40892 }
40893
40894
40895 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40896 PyObject *resultobj = 0;
40897 wxMenu *arg1 = (wxMenu *) 0 ;
40898 wxMenu *arg2 = (wxMenu *) 0 ;
40899 void *argp1 = 0 ;
40900 int res1 = 0 ;
40901 void *argp2 = 0 ;
40902 int res2 = 0 ;
40903 PyObject * obj0 = 0 ;
40904 PyObject * obj1 = 0 ;
40905 char * kwnames[] = {
40906 (char *) "self",(char *) "parent", NULL
40907 };
40908
40909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40911 if (!SWIG_IsOK(res1)) {
40912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40913 }
40914 arg1 = reinterpret_cast< wxMenu * >(argp1);
40915 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40916 if (!SWIG_IsOK(res2)) {
40917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40918 }
40919 arg2 = reinterpret_cast< wxMenu * >(argp2);
40920 {
40921 PyThreadState* __tstate = wxPyBeginAllowThreads();
40922 (arg1)->SetParent(arg2);
40923 wxPyEndAllowThreads(__tstate);
40924 if (PyErr_Occurred()) SWIG_fail;
40925 }
40926 resultobj = SWIG_Py_Void();
40927 return resultobj;
40928 fail:
40929 return NULL;
40930 }
40931
40932
40933 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40934 PyObject *resultobj = 0;
40935 wxMenu *arg1 = (wxMenu *) 0 ;
40936 wxMenu *result = 0 ;
40937 void *argp1 = 0 ;
40938 int res1 = 0 ;
40939 PyObject *swig_obj[1] ;
40940
40941 if (!args) SWIG_fail;
40942 swig_obj[0] = args;
40943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40944 if (!SWIG_IsOK(res1)) {
40945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40946 }
40947 arg1 = reinterpret_cast< wxMenu * >(argp1);
40948 {
40949 PyThreadState* __tstate = wxPyBeginAllowThreads();
40950 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40951 wxPyEndAllowThreads(__tstate);
40952 if (PyErr_Occurred()) SWIG_fail;
40953 }
40954 {
40955 resultobj = wxPyMake_wxObject(result, 0);
40956 }
40957 return resultobj;
40958 fail:
40959 return NULL;
40960 }
40961
40962
40963 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40964 PyObject *obj;
40965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40966 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40967 return SWIG_Py_Void();
40968 }
40969
40970 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40971 return SWIG_Python_InitShadowInstance(args);
40972 }
40973
40974 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40975 PyObject *resultobj = 0;
40976 long arg1 = (long) 0 ;
40977 wxMenuBar *result = 0 ;
40978 long val1 ;
40979 int ecode1 = 0 ;
40980 PyObject * obj0 = 0 ;
40981 char * kwnames[] = {
40982 (char *) "style", NULL
40983 };
40984
40985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40986 if (obj0) {
40987 ecode1 = SWIG_AsVal_long(obj0, &val1);
40988 if (!SWIG_IsOK(ecode1)) {
40989 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40990 }
40991 arg1 = static_cast< long >(val1);
40992 }
40993 {
40994 if (!wxPyCheckForApp()) SWIG_fail;
40995 PyThreadState* __tstate = wxPyBeginAllowThreads();
40996 result = (wxMenuBar *)new wxMenuBar(arg1);
40997 wxPyEndAllowThreads(__tstate);
40998 if (PyErr_Occurred()) SWIG_fail;
40999 }
41000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41001 return resultobj;
41002 fail:
41003 return NULL;
41004 }
41005
41006
41007 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41008 PyObject *resultobj = 0;
41009 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41010 wxMenu *arg2 = (wxMenu *) 0 ;
41011 wxString *arg3 = 0 ;
41012 bool result;
41013 void *argp1 = 0 ;
41014 int res1 = 0 ;
41015 void *argp2 = 0 ;
41016 int res2 = 0 ;
41017 bool temp3 = false ;
41018 PyObject * obj0 = 0 ;
41019 PyObject * obj1 = 0 ;
41020 PyObject * obj2 = 0 ;
41021 char * kwnames[] = {
41022 (char *) "self",(char *) "menu",(char *) "title", NULL
41023 };
41024
41025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41027 if (!SWIG_IsOK(res1)) {
41028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41029 }
41030 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41031 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41032 if (!SWIG_IsOK(res2)) {
41033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41034 }
41035 arg2 = reinterpret_cast< wxMenu * >(argp2);
41036 {
41037 arg3 = wxString_in_helper(obj2);
41038 if (arg3 == NULL) SWIG_fail;
41039 temp3 = true;
41040 }
41041 {
41042 PyThreadState* __tstate = wxPyBeginAllowThreads();
41043 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41044 wxPyEndAllowThreads(__tstate);
41045 if (PyErr_Occurred()) SWIG_fail;
41046 }
41047 {
41048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41049 }
41050 {
41051 if (temp3)
41052 delete arg3;
41053 }
41054 return resultobj;
41055 fail:
41056 {
41057 if (temp3)
41058 delete arg3;
41059 }
41060 return NULL;
41061 }
41062
41063
41064 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41065 PyObject *resultobj = 0;
41066 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41067 size_t arg2 ;
41068 wxMenu *arg3 = (wxMenu *) 0 ;
41069 wxString *arg4 = 0 ;
41070 bool result;
41071 void *argp1 = 0 ;
41072 int res1 = 0 ;
41073 size_t val2 ;
41074 int ecode2 = 0 ;
41075 void *argp3 = 0 ;
41076 int res3 = 0 ;
41077 bool temp4 = false ;
41078 PyObject * obj0 = 0 ;
41079 PyObject * obj1 = 0 ;
41080 PyObject * obj2 = 0 ;
41081 PyObject * obj3 = 0 ;
41082 char * kwnames[] = {
41083 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41084 };
41085
41086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41088 if (!SWIG_IsOK(res1)) {
41089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41090 }
41091 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41092 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41093 if (!SWIG_IsOK(ecode2)) {
41094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41095 }
41096 arg2 = static_cast< size_t >(val2);
41097 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41098 if (!SWIG_IsOK(res3)) {
41099 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41100 }
41101 arg3 = reinterpret_cast< wxMenu * >(argp3);
41102 {
41103 arg4 = wxString_in_helper(obj3);
41104 if (arg4 == NULL) SWIG_fail;
41105 temp4 = true;
41106 }
41107 {
41108 PyThreadState* __tstate = wxPyBeginAllowThreads();
41109 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41110 wxPyEndAllowThreads(__tstate);
41111 if (PyErr_Occurred()) SWIG_fail;
41112 }
41113 {
41114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41115 }
41116 {
41117 if (temp4)
41118 delete arg4;
41119 }
41120 return resultobj;
41121 fail:
41122 {
41123 if (temp4)
41124 delete arg4;
41125 }
41126 return NULL;
41127 }
41128
41129
41130 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41131 PyObject *resultobj = 0;
41132 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41133 size_t result;
41134 void *argp1 = 0 ;
41135 int res1 = 0 ;
41136 PyObject *swig_obj[1] ;
41137
41138 if (!args) SWIG_fail;
41139 swig_obj[0] = args;
41140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41141 if (!SWIG_IsOK(res1)) {
41142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41143 }
41144 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41145 {
41146 PyThreadState* __tstate = wxPyBeginAllowThreads();
41147 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41148 wxPyEndAllowThreads(__tstate);
41149 if (PyErr_Occurred()) SWIG_fail;
41150 }
41151 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41152 return resultobj;
41153 fail:
41154 return NULL;
41155 }
41156
41157
41158 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41159 PyObject *resultobj = 0;
41160 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41161 size_t arg2 ;
41162 wxMenu *result = 0 ;
41163 void *argp1 = 0 ;
41164 int res1 = 0 ;
41165 size_t val2 ;
41166 int ecode2 = 0 ;
41167 PyObject * obj0 = 0 ;
41168 PyObject * obj1 = 0 ;
41169 char * kwnames[] = {
41170 (char *) "self",(char *) "pos", NULL
41171 };
41172
41173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41175 if (!SWIG_IsOK(res1)) {
41176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41177 }
41178 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41179 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41180 if (!SWIG_IsOK(ecode2)) {
41181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41182 }
41183 arg2 = static_cast< size_t >(val2);
41184 {
41185 PyThreadState* __tstate = wxPyBeginAllowThreads();
41186 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41187 wxPyEndAllowThreads(__tstate);
41188 if (PyErr_Occurred()) SWIG_fail;
41189 }
41190 {
41191 resultobj = wxPyMake_wxObject(result, 0);
41192 }
41193 return resultobj;
41194 fail:
41195 return NULL;
41196 }
41197
41198
41199 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41200 PyObject *resultobj = 0;
41201 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41202 size_t arg2 ;
41203 wxMenu *arg3 = (wxMenu *) 0 ;
41204 wxString *arg4 = 0 ;
41205 wxMenu *result = 0 ;
41206 void *argp1 = 0 ;
41207 int res1 = 0 ;
41208 size_t val2 ;
41209 int ecode2 = 0 ;
41210 void *argp3 = 0 ;
41211 int res3 = 0 ;
41212 bool temp4 = false ;
41213 PyObject * obj0 = 0 ;
41214 PyObject * obj1 = 0 ;
41215 PyObject * obj2 = 0 ;
41216 PyObject * obj3 = 0 ;
41217 char * kwnames[] = {
41218 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41219 };
41220
41221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41223 if (!SWIG_IsOK(res1)) {
41224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41225 }
41226 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41227 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41228 if (!SWIG_IsOK(ecode2)) {
41229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41230 }
41231 arg2 = static_cast< size_t >(val2);
41232 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41233 if (!SWIG_IsOK(res3)) {
41234 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41235 }
41236 arg3 = reinterpret_cast< wxMenu * >(argp3);
41237 {
41238 arg4 = wxString_in_helper(obj3);
41239 if (arg4 == NULL) SWIG_fail;
41240 temp4 = true;
41241 }
41242 {
41243 PyThreadState* __tstate = wxPyBeginAllowThreads();
41244 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41245 wxPyEndAllowThreads(__tstate);
41246 if (PyErr_Occurred()) SWIG_fail;
41247 }
41248 {
41249 resultobj = wxPyMake_wxObject(result, 0);
41250 }
41251 {
41252 if (temp4)
41253 delete arg4;
41254 }
41255 return resultobj;
41256 fail:
41257 {
41258 if (temp4)
41259 delete arg4;
41260 }
41261 return NULL;
41262 }
41263
41264
41265 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41266 PyObject *resultobj = 0;
41267 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41268 size_t arg2 ;
41269 wxMenu *result = 0 ;
41270 void *argp1 = 0 ;
41271 int res1 = 0 ;
41272 size_t val2 ;
41273 int ecode2 = 0 ;
41274 PyObject * obj0 = 0 ;
41275 PyObject * obj1 = 0 ;
41276 char * kwnames[] = {
41277 (char *) "self",(char *) "pos", NULL
41278 };
41279
41280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41282 if (!SWIG_IsOK(res1)) {
41283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41284 }
41285 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41286 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41287 if (!SWIG_IsOK(ecode2)) {
41288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41289 }
41290 arg2 = static_cast< size_t >(val2);
41291 {
41292 PyThreadState* __tstate = wxPyBeginAllowThreads();
41293 result = (wxMenu *)(arg1)->Remove(arg2);
41294 wxPyEndAllowThreads(__tstate);
41295 if (PyErr_Occurred()) SWIG_fail;
41296 }
41297 {
41298 resultobj = wxPyMake_wxObject(result, 0);
41299 }
41300 return resultobj;
41301 fail:
41302 return NULL;
41303 }
41304
41305
41306 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41307 PyObject *resultobj = 0;
41308 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41309 size_t arg2 ;
41310 bool arg3 ;
41311 void *argp1 = 0 ;
41312 int res1 = 0 ;
41313 size_t val2 ;
41314 int ecode2 = 0 ;
41315 bool val3 ;
41316 int ecode3 = 0 ;
41317 PyObject * obj0 = 0 ;
41318 PyObject * obj1 = 0 ;
41319 PyObject * obj2 = 0 ;
41320 char * kwnames[] = {
41321 (char *) "self",(char *) "pos",(char *) "enable", NULL
41322 };
41323
41324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41326 if (!SWIG_IsOK(res1)) {
41327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41328 }
41329 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41330 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41331 if (!SWIG_IsOK(ecode2)) {
41332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41333 }
41334 arg2 = static_cast< size_t >(val2);
41335 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41336 if (!SWIG_IsOK(ecode3)) {
41337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41338 }
41339 arg3 = static_cast< bool >(val3);
41340 {
41341 PyThreadState* __tstate = wxPyBeginAllowThreads();
41342 (arg1)->EnableTop(arg2,arg3);
41343 wxPyEndAllowThreads(__tstate);
41344 if (PyErr_Occurred()) SWIG_fail;
41345 }
41346 resultobj = SWIG_Py_Void();
41347 return resultobj;
41348 fail:
41349 return NULL;
41350 }
41351
41352
41353 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41354 PyObject *resultobj = 0;
41355 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41356 size_t arg2 ;
41357 bool result;
41358 void *argp1 = 0 ;
41359 int res1 = 0 ;
41360 size_t val2 ;
41361 int ecode2 = 0 ;
41362 PyObject * obj0 = 0 ;
41363 PyObject * obj1 = 0 ;
41364 char * kwnames[] = {
41365 (char *) "self",(char *) "pos", NULL
41366 };
41367
41368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41370 if (!SWIG_IsOK(res1)) {
41371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41372 }
41373 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41374 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41375 if (!SWIG_IsOK(ecode2)) {
41376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41377 }
41378 arg2 = static_cast< size_t >(val2);
41379 {
41380 PyThreadState* __tstate = wxPyBeginAllowThreads();
41381 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41382 wxPyEndAllowThreads(__tstate);
41383 if (PyErr_Occurred()) SWIG_fail;
41384 }
41385 {
41386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41387 }
41388 return resultobj;
41389 fail:
41390 return NULL;
41391 }
41392
41393
41394 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41395 PyObject *resultobj = 0;
41396 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41397 size_t arg2 ;
41398 wxString *arg3 = 0 ;
41399 void *argp1 = 0 ;
41400 int res1 = 0 ;
41401 size_t val2 ;
41402 int ecode2 = 0 ;
41403 bool temp3 = false ;
41404 PyObject * obj0 = 0 ;
41405 PyObject * obj1 = 0 ;
41406 PyObject * obj2 = 0 ;
41407 char * kwnames[] = {
41408 (char *) "self",(char *) "pos",(char *) "label", NULL
41409 };
41410
41411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41413 if (!SWIG_IsOK(res1)) {
41414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41415 }
41416 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41417 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41418 if (!SWIG_IsOK(ecode2)) {
41419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41420 }
41421 arg2 = static_cast< size_t >(val2);
41422 {
41423 arg3 = wxString_in_helper(obj2);
41424 if (arg3 == NULL) SWIG_fail;
41425 temp3 = true;
41426 }
41427 {
41428 PyThreadState* __tstate = wxPyBeginAllowThreads();
41429 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41430 wxPyEndAllowThreads(__tstate);
41431 if (PyErr_Occurred()) SWIG_fail;
41432 }
41433 resultobj = SWIG_Py_Void();
41434 {
41435 if (temp3)
41436 delete arg3;
41437 }
41438 return resultobj;
41439 fail:
41440 {
41441 if (temp3)
41442 delete arg3;
41443 }
41444 return NULL;
41445 }
41446
41447
41448 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41449 PyObject *resultobj = 0;
41450 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41451 size_t arg2 ;
41452 wxString result;
41453 void *argp1 = 0 ;
41454 int res1 = 0 ;
41455 size_t val2 ;
41456 int ecode2 = 0 ;
41457 PyObject * obj0 = 0 ;
41458 PyObject * obj1 = 0 ;
41459 char * kwnames[] = {
41460 (char *) "self",(char *) "pos", NULL
41461 };
41462
41463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41465 if (!SWIG_IsOK(res1)) {
41466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41467 }
41468 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41469 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41470 if (!SWIG_IsOK(ecode2)) {
41471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41472 }
41473 arg2 = static_cast< size_t >(val2);
41474 {
41475 PyThreadState* __tstate = wxPyBeginAllowThreads();
41476 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41477 wxPyEndAllowThreads(__tstate);
41478 if (PyErr_Occurred()) SWIG_fail;
41479 }
41480 {
41481 #if wxUSE_UNICODE
41482 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41483 #else
41484 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41485 #endif
41486 }
41487 return resultobj;
41488 fail:
41489 return NULL;
41490 }
41491
41492
41493 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41494 PyObject *resultobj = 0;
41495 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41496 wxString *arg2 = 0 ;
41497 wxString *arg3 = 0 ;
41498 int result;
41499 void *argp1 = 0 ;
41500 int res1 = 0 ;
41501 bool temp2 = false ;
41502 bool temp3 = false ;
41503 PyObject * obj0 = 0 ;
41504 PyObject * obj1 = 0 ;
41505 PyObject * obj2 = 0 ;
41506 char * kwnames[] = {
41507 (char *) "self",(char *) "menu",(char *) "item", NULL
41508 };
41509
41510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41512 if (!SWIG_IsOK(res1)) {
41513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41514 }
41515 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41516 {
41517 arg2 = wxString_in_helper(obj1);
41518 if (arg2 == NULL) SWIG_fail;
41519 temp2 = true;
41520 }
41521 {
41522 arg3 = wxString_in_helper(obj2);
41523 if (arg3 == NULL) SWIG_fail;
41524 temp3 = true;
41525 }
41526 {
41527 PyThreadState* __tstate = wxPyBeginAllowThreads();
41528 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41529 wxPyEndAllowThreads(__tstate);
41530 if (PyErr_Occurred()) SWIG_fail;
41531 }
41532 resultobj = SWIG_From_int(static_cast< int >(result));
41533 {
41534 if (temp2)
41535 delete arg2;
41536 }
41537 {
41538 if (temp3)
41539 delete arg3;
41540 }
41541 return resultobj;
41542 fail:
41543 {
41544 if (temp2)
41545 delete arg2;
41546 }
41547 {
41548 if (temp3)
41549 delete arg3;
41550 }
41551 return NULL;
41552 }
41553
41554
41555 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41556 PyObject *resultobj = 0;
41557 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41558 int arg2 ;
41559 wxMenuItem *result = 0 ;
41560 void *argp1 = 0 ;
41561 int res1 = 0 ;
41562 int val2 ;
41563 int ecode2 = 0 ;
41564 PyObject * obj0 = 0 ;
41565 PyObject * obj1 = 0 ;
41566 char * kwnames[] = {
41567 (char *) "self",(char *) "id", NULL
41568 };
41569
41570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41572 if (!SWIG_IsOK(res1)) {
41573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41574 }
41575 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41576 ecode2 = SWIG_AsVal_int(obj1, &val2);
41577 if (!SWIG_IsOK(ecode2)) {
41578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41579 }
41580 arg2 = static_cast< int >(val2);
41581 {
41582 PyThreadState* __tstate = wxPyBeginAllowThreads();
41583 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41584 wxPyEndAllowThreads(__tstate);
41585 if (PyErr_Occurred()) SWIG_fail;
41586 }
41587 {
41588 resultobj = wxPyMake_wxObject(result, (bool)0);
41589 }
41590 return resultobj;
41591 fail:
41592 return NULL;
41593 }
41594
41595
41596 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41597 PyObject *resultobj = 0;
41598 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41599 wxString *arg2 = 0 ;
41600 int result;
41601 void *argp1 = 0 ;
41602 int res1 = 0 ;
41603 bool temp2 = false ;
41604 PyObject * obj0 = 0 ;
41605 PyObject * obj1 = 0 ;
41606 char * kwnames[] = {
41607 (char *) "self",(char *) "title", NULL
41608 };
41609
41610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41612 if (!SWIG_IsOK(res1)) {
41613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41614 }
41615 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41616 {
41617 arg2 = wxString_in_helper(obj1);
41618 if (arg2 == NULL) SWIG_fail;
41619 temp2 = true;
41620 }
41621 {
41622 PyThreadState* __tstate = wxPyBeginAllowThreads();
41623 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41624 wxPyEndAllowThreads(__tstate);
41625 if (PyErr_Occurred()) SWIG_fail;
41626 }
41627 resultobj = SWIG_From_int(static_cast< int >(result));
41628 {
41629 if (temp2)
41630 delete arg2;
41631 }
41632 return resultobj;
41633 fail:
41634 {
41635 if (temp2)
41636 delete arg2;
41637 }
41638 return NULL;
41639 }
41640
41641
41642 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41643 PyObject *resultobj = 0;
41644 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41645 int arg2 ;
41646 bool arg3 ;
41647 void *argp1 = 0 ;
41648 int res1 = 0 ;
41649 int val2 ;
41650 int ecode2 = 0 ;
41651 bool val3 ;
41652 int ecode3 = 0 ;
41653 PyObject * obj0 = 0 ;
41654 PyObject * obj1 = 0 ;
41655 PyObject * obj2 = 0 ;
41656 char * kwnames[] = {
41657 (char *) "self",(char *) "id",(char *) "enable", NULL
41658 };
41659
41660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41662 if (!SWIG_IsOK(res1)) {
41663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41664 }
41665 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41666 ecode2 = SWIG_AsVal_int(obj1, &val2);
41667 if (!SWIG_IsOK(ecode2)) {
41668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41669 }
41670 arg2 = static_cast< int >(val2);
41671 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41672 if (!SWIG_IsOK(ecode3)) {
41673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41674 }
41675 arg3 = static_cast< bool >(val3);
41676 {
41677 PyThreadState* __tstate = wxPyBeginAllowThreads();
41678 (arg1)->Enable(arg2,arg3);
41679 wxPyEndAllowThreads(__tstate);
41680 if (PyErr_Occurred()) SWIG_fail;
41681 }
41682 resultobj = SWIG_Py_Void();
41683 return resultobj;
41684 fail:
41685 return NULL;
41686 }
41687
41688
41689 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41690 PyObject *resultobj = 0;
41691 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41692 int arg2 ;
41693 bool arg3 ;
41694 void *argp1 = 0 ;
41695 int res1 = 0 ;
41696 int val2 ;
41697 int ecode2 = 0 ;
41698 bool val3 ;
41699 int ecode3 = 0 ;
41700 PyObject * obj0 = 0 ;
41701 PyObject * obj1 = 0 ;
41702 PyObject * obj2 = 0 ;
41703 char * kwnames[] = {
41704 (char *) "self",(char *) "id",(char *) "check", NULL
41705 };
41706
41707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41709 if (!SWIG_IsOK(res1)) {
41710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41711 }
41712 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41713 ecode2 = SWIG_AsVal_int(obj1, &val2);
41714 if (!SWIG_IsOK(ecode2)) {
41715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41716 }
41717 arg2 = static_cast< int >(val2);
41718 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41719 if (!SWIG_IsOK(ecode3)) {
41720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41721 }
41722 arg3 = static_cast< bool >(val3);
41723 {
41724 PyThreadState* __tstate = wxPyBeginAllowThreads();
41725 (arg1)->Check(arg2,arg3);
41726 wxPyEndAllowThreads(__tstate);
41727 if (PyErr_Occurred()) SWIG_fail;
41728 }
41729 resultobj = SWIG_Py_Void();
41730 return resultobj;
41731 fail:
41732 return NULL;
41733 }
41734
41735
41736 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41737 PyObject *resultobj = 0;
41738 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41739 int arg2 ;
41740 bool result;
41741 void *argp1 = 0 ;
41742 int res1 = 0 ;
41743 int val2 ;
41744 int ecode2 = 0 ;
41745 PyObject * obj0 = 0 ;
41746 PyObject * obj1 = 0 ;
41747 char * kwnames[] = {
41748 (char *) "self",(char *) "id", NULL
41749 };
41750
41751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41753 if (!SWIG_IsOK(res1)) {
41754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41755 }
41756 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41757 ecode2 = SWIG_AsVal_int(obj1, &val2);
41758 if (!SWIG_IsOK(ecode2)) {
41759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41760 }
41761 arg2 = static_cast< int >(val2);
41762 {
41763 PyThreadState* __tstate = wxPyBeginAllowThreads();
41764 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41765 wxPyEndAllowThreads(__tstate);
41766 if (PyErr_Occurred()) SWIG_fail;
41767 }
41768 {
41769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41770 }
41771 return resultobj;
41772 fail:
41773 return NULL;
41774 }
41775
41776
41777 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41778 PyObject *resultobj = 0;
41779 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41780 int arg2 ;
41781 bool result;
41782 void *argp1 = 0 ;
41783 int res1 = 0 ;
41784 int val2 ;
41785 int ecode2 = 0 ;
41786 PyObject * obj0 = 0 ;
41787 PyObject * obj1 = 0 ;
41788 char * kwnames[] = {
41789 (char *) "self",(char *) "id", NULL
41790 };
41791
41792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41794 if (!SWIG_IsOK(res1)) {
41795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41796 }
41797 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41798 ecode2 = SWIG_AsVal_int(obj1, &val2);
41799 if (!SWIG_IsOK(ecode2)) {
41800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41801 }
41802 arg2 = static_cast< int >(val2);
41803 {
41804 PyThreadState* __tstate = wxPyBeginAllowThreads();
41805 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41806 wxPyEndAllowThreads(__tstate);
41807 if (PyErr_Occurred()) SWIG_fail;
41808 }
41809 {
41810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41811 }
41812 return resultobj;
41813 fail:
41814 return NULL;
41815 }
41816
41817
41818 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41819 PyObject *resultobj = 0;
41820 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41821 int arg2 ;
41822 wxString *arg3 = 0 ;
41823 void *argp1 = 0 ;
41824 int res1 = 0 ;
41825 int val2 ;
41826 int ecode2 = 0 ;
41827 bool temp3 = false ;
41828 PyObject * obj0 = 0 ;
41829 PyObject * obj1 = 0 ;
41830 PyObject * obj2 = 0 ;
41831 char * kwnames[] = {
41832 (char *) "self",(char *) "id",(char *) "label", NULL
41833 };
41834
41835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41837 if (!SWIG_IsOK(res1)) {
41838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41839 }
41840 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41841 ecode2 = SWIG_AsVal_int(obj1, &val2);
41842 if (!SWIG_IsOK(ecode2)) {
41843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41844 }
41845 arg2 = static_cast< int >(val2);
41846 {
41847 arg3 = wxString_in_helper(obj2);
41848 if (arg3 == NULL) SWIG_fail;
41849 temp3 = true;
41850 }
41851 {
41852 PyThreadState* __tstate = wxPyBeginAllowThreads();
41853 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41854 wxPyEndAllowThreads(__tstate);
41855 if (PyErr_Occurred()) SWIG_fail;
41856 }
41857 resultobj = SWIG_Py_Void();
41858 {
41859 if (temp3)
41860 delete arg3;
41861 }
41862 return resultobj;
41863 fail:
41864 {
41865 if (temp3)
41866 delete arg3;
41867 }
41868 return NULL;
41869 }
41870
41871
41872 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41873 PyObject *resultobj = 0;
41874 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41875 int arg2 ;
41876 wxString result;
41877 void *argp1 = 0 ;
41878 int res1 = 0 ;
41879 int val2 ;
41880 int ecode2 = 0 ;
41881 PyObject * obj0 = 0 ;
41882 PyObject * obj1 = 0 ;
41883 char * kwnames[] = {
41884 (char *) "self",(char *) "id", NULL
41885 };
41886
41887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41889 if (!SWIG_IsOK(res1)) {
41890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41891 }
41892 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41893 ecode2 = SWIG_AsVal_int(obj1, &val2);
41894 if (!SWIG_IsOK(ecode2)) {
41895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41896 }
41897 arg2 = static_cast< int >(val2);
41898 {
41899 PyThreadState* __tstate = wxPyBeginAllowThreads();
41900 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41901 wxPyEndAllowThreads(__tstate);
41902 if (PyErr_Occurred()) SWIG_fail;
41903 }
41904 {
41905 #if wxUSE_UNICODE
41906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41907 #else
41908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41909 #endif
41910 }
41911 return resultobj;
41912 fail:
41913 return NULL;
41914 }
41915
41916
41917 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41918 PyObject *resultobj = 0;
41919 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41920 int arg2 ;
41921 wxString *arg3 = 0 ;
41922 void *argp1 = 0 ;
41923 int res1 = 0 ;
41924 int val2 ;
41925 int ecode2 = 0 ;
41926 bool temp3 = false ;
41927 PyObject * obj0 = 0 ;
41928 PyObject * obj1 = 0 ;
41929 PyObject * obj2 = 0 ;
41930 char * kwnames[] = {
41931 (char *) "self",(char *) "id",(char *) "helpString", NULL
41932 };
41933
41934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41936 if (!SWIG_IsOK(res1)) {
41937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41938 }
41939 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41940 ecode2 = SWIG_AsVal_int(obj1, &val2);
41941 if (!SWIG_IsOK(ecode2)) {
41942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41943 }
41944 arg2 = static_cast< int >(val2);
41945 {
41946 arg3 = wxString_in_helper(obj2);
41947 if (arg3 == NULL) SWIG_fail;
41948 temp3 = true;
41949 }
41950 {
41951 PyThreadState* __tstate = wxPyBeginAllowThreads();
41952 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41953 wxPyEndAllowThreads(__tstate);
41954 if (PyErr_Occurred()) SWIG_fail;
41955 }
41956 resultobj = SWIG_Py_Void();
41957 {
41958 if (temp3)
41959 delete arg3;
41960 }
41961 return resultobj;
41962 fail:
41963 {
41964 if (temp3)
41965 delete arg3;
41966 }
41967 return NULL;
41968 }
41969
41970
41971 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41972 PyObject *resultobj = 0;
41973 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41974 int arg2 ;
41975 wxString result;
41976 void *argp1 = 0 ;
41977 int res1 = 0 ;
41978 int val2 ;
41979 int ecode2 = 0 ;
41980 PyObject * obj0 = 0 ;
41981 PyObject * obj1 = 0 ;
41982 char * kwnames[] = {
41983 (char *) "self",(char *) "id", NULL
41984 };
41985
41986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41988 if (!SWIG_IsOK(res1)) {
41989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41990 }
41991 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41992 ecode2 = SWIG_AsVal_int(obj1, &val2);
41993 if (!SWIG_IsOK(ecode2)) {
41994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41995 }
41996 arg2 = static_cast< int >(val2);
41997 {
41998 PyThreadState* __tstate = wxPyBeginAllowThreads();
41999 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42000 wxPyEndAllowThreads(__tstate);
42001 if (PyErr_Occurred()) SWIG_fail;
42002 }
42003 {
42004 #if wxUSE_UNICODE
42005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42006 #else
42007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42008 #endif
42009 }
42010 return resultobj;
42011 fail:
42012 return NULL;
42013 }
42014
42015
42016 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42017 PyObject *resultobj = 0;
42018 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42019 wxFrame *result = 0 ;
42020 void *argp1 = 0 ;
42021 int res1 = 0 ;
42022 PyObject *swig_obj[1] ;
42023
42024 if (!args) SWIG_fail;
42025 swig_obj[0] = args;
42026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42027 if (!SWIG_IsOK(res1)) {
42028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42029 }
42030 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42031 {
42032 PyThreadState* __tstate = wxPyBeginAllowThreads();
42033 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42034 wxPyEndAllowThreads(__tstate);
42035 if (PyErr_Occurred()) SWIG_fail;
42036 }
42037 {
42038 resultobj = wxPyMake_wxObject(result, (bool)0);
42039 }
42040 return resultobj;
42041 fail:
42042 return NULL;
42043 }
42044
42045
42046 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42047 PyObject *resultobj = 0;
42048 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42049 bool result;
42050 void *argp1 = 0 ;
42051 int res1 = 0 ;
42052 PyObject *swig_obj[1] ;
42053
42054 if (!args) SWIG_fail;
42055 swig_obj[0] = args;
42056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42057 if (!SWIG_IsOK(res1)) {
42058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42059 }
42060 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42061 {
42062 PyThreadState* __tstate = wxPyBeginAllowThreads();
42063 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42064 wxPyEndAllowThreads(__tstate);
42065 if (PyErr_Occurred()) SWIG_fail;
42066 }
42067 {
42068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42069 }
42070 return resultobj;
42071 fail:
42072 return NULL;
42073 }
42074
42075
42076 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42077 PyObject *resultobj = 0;
42078 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42079 wxFrame *arg2 = (wxFrame *) 0 ;
42080 void *argp1 = 0 ;
42081 int res1 = 0 ;
42082 void *argp2 = 0 ;
42083 int res2 = 0 ;
42084 PyObject * obj0 = 0 ;
42085 PyObject * obj1 = 0 ;
42086 char * kwnames[] = {
42087 (char *) "self",(char *) "frame", NULL
42088 };
42089
42090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42092 if (!SWIG_IsOK(res1)) {
42093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42094 }
42095 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42096 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42097 if (!SWIG_IsOK(res2)) {
42098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42099 }
42100 arg2 = reinterpret_cast< wxFrame * >(argp2);
42101 {
42102 PyThreadState* __tstate = wxPyBeginAllowThreads();
42103 (arg1)->Attach(arg2);
42104 wxPyEndAllowThreads(__tstate);
42105 if (PyErr_Occurred()) SWIG_fail;
42106 }
42107 resultobj = SWIG_Py_Void();
42108 return resultobj;
42109 fail:
42110 return NULL;
42111 }
42112
42113
42114 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42115 PyObject *resultobj = 0;
42116 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42117 void *argp1 = 0 ;
42118 int res1 = 0 ;
42119 PyObject *swig_obj[1] ;
42120
42121 if (!args) SWIG_fail;
42122 swig_obj[0] = args;
42123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42124 if (!SWIG_IsOK(res1)) {
42125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42126 }
42127 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42128 {
42129 PyThreadState* __tstate = wxPyBeginAllowThreads();
42130 (arg1)->Detach();
42131 wxPyEndAllowThreads(__tstate);
42132 if (PyErr_Occurred()) SWIG_fail;
42133 }
42134 resultobj = SWIG_Py_Void();
42135 return resultobj;
42136 fail:
42137 return NULL;
42138 }
42139
42140
42141 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42142 PyObject *resultobj = 0;
42143 bool arg1 ;
42144 bool val1 ;
42145 int ecode1 = 0 ;
42146 PyObject * obj0 = 0 ;
42147 char * kwnames[] = {
42148 (char *) "enable", NULL
42149 };
42150
42151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42152 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42153 if (!SWIG_IsOK(ecode1)) {
42154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42155 }
42156 arg1 = static_cast< bool >(val1);
42157 {
42158 PyThreadState* __tstate = wxPyBeginAllowThreads();
42159 wxMenuBar_SetAutoWindowMenu(arg1);
42160 wxPyEndAllowThreads(__tstate);
42161 if (PyErr_Occurred()) SWIG_fail;
42162 }
42163 resultobj = SWIG_Py_Void();
42164 return resultobj;
42165 fail:
42166 return NULL;
42167 }
42168
42169
42170 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42171 PyObject *resultobj = 0;
42172 bool result;
42173
42174 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42175 {
42176 PyThreadState* __tstate = wxPyBeginAllowThreads();
42177 result = (bool)wxMenuBar_GetAutoWindowMenu();
42178 wxPyEndAllowThreads(__tstate);
42179 if (PyErr_Occurred()) SWIG_fail;
42180 }
42181 {
42182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42183 }
42184 return resultobj;
42185 fail:
42186 return NULL;
42187 }
42188
42189
42190 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42191 PyObject *obj;
42192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42193 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42194 return SWIG_Py_Void();
42195 }
42196
42197 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42198 return SWIG_Python_InitShadowInstance(args);
42199 }
42200
42201 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42202 PyObject *resultobj = 0;
42203 wxMenu *arg1 = (wxMenu *) NULL ;
42204 int arg2 = (int) wxID_ANY ;
42205 wxString const &arg3_defvalue = wxPyEmptyString ;
42206 wxString *arg3 = (wxString *) &arg3_defvalue ;
42207 wxString const &arg4_defvalue = wxPyEmptyString ;
42208 wxString *arg4 = (wxString *) &arg4_defvalue ;
42209 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42210 wxMenu *arg6 = (wxMenu *) NULL ;
42211 wxMenuItem *result = 0 ;
42212 void *argp1 = 0 ;
42213 int res1 = 0 ;
42214 int val2 ;
42215 int ecode2 = 0 ;
42216 bool temp3 = false ;
42217 bool temp4 = false ;
42218 int val5 ;
42219 int ecode5 = 0 ;
42220 void *argp6 = 0 ;
42221 int res6 = 0 ;
42222 PyObject * obj0 = 0 ;
42223 PyObject * obj1 = 0 ;
42224 PyObject * obj2 = 0 ;
42225 PyObject * obj3 = 0 ;
42226 PyObject * obj4 = 0 ;
42227 PyObject * obj5 = 0 ;
42228 char * kwnames[] = {
42229 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42230 };
42231
42232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42233 if (obj0) {
42234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42235 if (!SWIG_IsOK(res1)) {
42236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42237 }
42238 arg1 = reinterpret_cast< wxMenu * >(argp1);
42239 }
42240 if (obj1) {
42241 ecode2 = SWIG_AsVal_int(obj1, &val2);
42242 if (!SWIG_IsOK(ecode2)) {
42243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42244 }
42245 arg2 = static_cast< int >(val2);
42246 }
42247 if (obj2) {
42248 {
42249 arg3 = wxString_in_helper(obj2);
42250 if (arg3 == NULL) SWIG_fail;
42251 temp3 = true;
42252 }
42253 }
42254 if (obj3) {
42255 {
42256 arg4 = wxString_in_helper(obj3);
42257 if (arg4 == NULL) SWIG_fail;
42258 temp4 = true;
42259 }
42260 }
42261 if (obj4) {
42262 ecode5 = SWIG_AsVal_int(obj4, &val5);
42263 if (!SWIG_IsOK(ecode5)) {
42264 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42265 }
42266 arg5 = static_cast< wxItemKind >(val5);
42267 }
42268 if (obj5) {
42269 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42270 if (!SWIG_IsOK(res6)) {
42271 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42272 }
42273 arg6 = reinterpret_cast< wxMenu * >(argp6);
42274 }
42275 {
42276 PyThreadState* __tstate = wxPyBeginAllowThreads();
42277 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42278 wxPyEndAllowThreads(__tstate);
42279 if (PyErr_Occurred()) SWIG_fail;
42280 }
42281 {
42282 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42283 }
42284 {
42285 if (temp3)
42286 delete arg3;
42287 }
42288 {
42289 if (temp4)
42290 delete arg4;
42291 }
42292 return resultobj;
42293 fail:
42294 {
42295 if (temp3)
42296 delete arg3;
42297 }
42298 {
42299 if (temp4)
42300 delete arg4;
42301 }
42302 return NULL;
42303 }
42304
42305
42306 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42307 PyObject *resultobj = 0;
42308 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42309 void *argp1 = 0 ;
42310 int res1 = 0 ;
42311 PyObject *swig_obj[1] ;
42312
42313 if (!args) SWIG_fail;
42314 swig_obj[0] = args;
42315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42316 if (!SWIG_IsOK(res1)) {
42317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42318 }
42319 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42320 {
42321 PyThreadState* __tstate = wxPyBeginAllowThreads();
42322 delete arg1;
42323
42324 wxPyEndAllowThreads(__tstate);
42325 if (PyErr_Occurred()) SWIG_fail;
42326 }
42327 resultobj = SWIG_Py_Void();
42328 return resultobj;
42329 fail:
42330 return NULL;
42331 }
42332
42333
42334 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42335 PyObject *resultobj = 0;
42336 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42337 wxMenu *result = 0 ;
42338 void *argp1 = 0 ;
42339 int res1 = 0 ;
42340 PyObject *swig_obj[1] ;
42341
42342 if (!args) SWIG_fail;
42343 swig_obj[0] = args;
42344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42345 if (!SWIG_IsOK(res1)) {
42346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42347 }
42348 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42349 {
42350 PyThreadState* __tstate = wxPyBeginAllowThreads();
42351 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42352 wxPyEndAllowThreads(__tstate);
42353 if (PyErr_Occurred()) SWIG_fail;
42354 }
42355 {
42356 resultobj = wxPyMake_wxObject(result, 0);
42357 }
42358 return resultobj;
42359 fail:
42360 return NULL;
42361 }
42362
42363
42364 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42365 PyObject *resultobj = 0;
42366 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42367 wxMenu *arg2 = (wxMenu *) 0 ;
42368 void *argp1 = 0 ;
42369 int res1 = 0 ;
42370 void *argp2 = 0 ;
42371 int res2 = 0 ;
42372 PyObject * obj0 = 0 ;
42373 PyObject * obj1 = 0 ;
42374 char * kwnames[] = {
42375 (char *) "self",(char *) "menu", NULL
42376 };
42377
42378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42380 if (!SWIG_IsOK(res1)) {
42381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42382 }
42383 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42384 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42385 if (!SWIG_IsOK(res2)) {
42386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42387 }
42388 arg2 = reinterpret_cast< wxMenu * >(argp2);
42389 {
42390 PyThreadState* __tstate = wxPyBeginAllowThreads();
42391 (arg1)->SetMenu(arg2);
42392 wxPyEndAllowThreads(__tstate);
42393 if (PyErr_Occurred()) SWIG_fail;
42394 }
42395 resultobj = SWIG_Py_Void();
42396 return resultobj;
42397 fail:
42398 return NULL;
42399 }
42400
42401
42402 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42403 PyObject *resultobj = 0;
42404 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42405 int arg2 ;
42406 void *argp1 = 0 ;
42407 int res1 = 0 ;
42408 int val2 ;
42409 int ecode2 = 0 ;
42410 PyObject * obj0 = 0 ;
42411 PyObject * obj1 = 0 ;
42412 char * kwnames[] = {
42413 (char *) "self",(char *) "id", NULL
42414 };
42415
42416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42418 if (!SWIG_IsOK(res1)) {
42419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42420 }
42421 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42422 ecode2 = SWIG_AsVal_int(obj1, &val2);
42423 if (!SWIG_IsOK(ecode2)) {
42424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42425 }
42426 arg2 = static_cast< int >(val2);
42427 {
42428 PyThreadState* __tstate = wxPyBeginAllowThreads();
42429 (arg1)->SetId(arg2);
42430 wxPyEndAllowThreads(__tstate);
42431 if (PyErr_Occurred()) SWIG_fail;
42432 }
42433 resultobj = SWIG_Py_Void();
42434 return resultobj;
42435 fail:
42436 return NULL;
42437 }
42438
42439
42440 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42441 PyObject *resultobj = 0;
42442 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42443 int result;
42444 void *argp1 = 0 ;
42445 int res1 = 0 ;
42446 PyObject *swig_obj[1] ;
42447
42448 if (!args) SWIG_fail;
42449 swig_obj[0] = args;
42450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42451 if (!SWIG_IsOK(res1)) {
42452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42453 }
42454 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42455 {
42456 PyThreadState* __tstate = wxPyBeginAllowThreads();
42457 result = (int)((wxMenuItem const *)arg1)->GetId();
42458 wxPyEndAllowThreads(__tstate);
42459 if (PyErr_Occurred()) SWIG_fail;
42460 }
42461 resultobj = SWIG_From_int(static_cast< int >(result));
42462 return resultobj;
42463 fail:
42464 return NULL;
42465 }
42466
42467
42468 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42469 PyObject *resultobj = 0;
42470 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42471 bool result;
42472 void *argp1 = 0 ;
42473 int res1 = 0 ;
42474 PyObject *swig_obj[1] ;
42475
42476 if (!args) SWIG_fail;
42477 swig_obj[0] = args;
42478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42479 if (!SWIG_IsOK(res1)) {
42480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42481 }
42482 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42483 {
42484 PyThreadState* __tstate = wxPyBeginAllowThreads();
42485 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42486 wxPyEndAllowThreads(__tstate);
42487 if (PyErr_Occurred()) SWIG_fail;
42488 }
42489 {
42490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42491 }
42492 return resultobj;
42493 fail:
42494 return NULL;
42495 }
42496
42497
42498 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42499 PyObject *resultobj = 0;
42500 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42501 wxString *arg2 = 0 ;
42502 void *argp1 = 0 ;
42503 int res1 = 0 ;
42504 bool temp2 = false ;
42505 PyObject * obj0 = 0 ;
42506 PyObject * obj1 = 0 ;
42507 char * kwnames[] = {
42508 (char *) "self",(char *) "str", NULL
42509 };
42510
42511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42513 if (!SWIG_IsOK(res1)) {
42514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42515 }
42516 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42517 {
42518 arg2 = wxString_in_helper(obj1);
42519 if (arg2 == NULL) SWIG_fail;
42520 temp2 = true;
42521 }
42522 {
42523 PyThreadState* __tstate = wxPyBeginAllowThreads();
42524 (arg1)->SetText((wxString const &)*arg2);
42525 wxPyEndAllowThreads(__tstate);
42526 if (PyErr_Occurred()) SWIG_fail;
42527 }
42528 resultobj = SWIG_Py_Void();
42529 {
42530 if (temp2)
42531 delete arg2;
42532 }
42533 return resultobj;
42534 fail:
42535 {
42536 if (temp2)
42537 delete arg2;
42538 }
42539 return NULL;
42540 }
42541
42542
42543 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42544 PyObject *resultobj = 0;
42545 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42546 wxString result;
42547 void *argp1 = 0 ;
42548 int res1 = 0 ;
42549 PyObject *swig_obj[1] ;
42550
42551 if (!args) SWIG_fail;
42552 swig_obj[0] = args;
42553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42554 if (!SWIG_IsOK(res1)) {
42555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42556 }
42557 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42558 {
42559 PyThreadState* __tstate = wxPyBeginAllowThreads();
42560 result = ((wxMenuItem const *)arg1)->GetLabel();
42561 wxPyEndAllowThreads(__tstate);
42562 if (PyErr_Occurred()) SWIG_fail;
42563 }
42564 {
42565 #if wxUSE_UNICODE
42566 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42567 #else
42568 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42569 #endif
42570 }
42571 return resultobj;
42572 fail:
42573 return NULL;
42574 }
42575
42576
42577 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42578 PyObject *resultobj = 0;
42579 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42580 wxString *result = 0 ;
42581 void *argp1 = 0 ;
42582 int res1 = 0 ;
42583 PyObject *swig_obj[1] ;
42584
42585 if (!args) SWIG_fail;
42586 swig_obj[0] = args;
42587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42588 if (!SWIG_IsOK(res1)) {
42589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42590 }
42591 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42592 {
42593 PyThreadState* __tstate = wxPyBeginAllowThreads();
42594 {
42595 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42596 result = (wxString *) &_result_ref;
42597 }
42598 wxPyEndAllowThreads(__tstate);
42599 if (PyErr_Occurred()) SWIG_fail;
42600 }
42601 {
42602 #if wxUSE_UNICODE
42603 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42604 #else
42605 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42606 #endif
42607 }
42608 return resultobj;
42609 fail:
42610 return NULL;
42611 }
42612
42613
42614 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42615 PyObject *resultobj = 0;
42616 wxString *arg1 = 0 ;
42617 wxString result;
42618 bool temp1 = false ;
42619 PyObject * obj0 = 0 ;
42620 char * kwnames[] = {
42621 (char *) "text", NULL
42622 };
42623
42624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42625 {
42626 arg1 = wxString_in_helper(obj0);
42627 if (arg1 == NULL) SWIG_fail;
42628 temp1 = true;
42629 }
42630 {
42631 PyThreadState* __tstate = wxPyBeginAllowThreads();
42632 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42633 wxPyEndAllowThreads(__tstate);
42634 if (PyErr_Occurred()) SWIG_fail;
42635 }
42636 {
42637 #if wxUSE_UNICODE
42638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42639 #else
42640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42641 #endif
42642 }
42643 {
42644 if (temp1)
42645 delete arg1;
42646 }
42647 return resultobj;
42648 fail:
42649 {
42650 if (temp1)
42651 delete arg1;
42652 }
42653 return NULL;
42654 }
42655
42656
42657 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42658 PyObject *resultobj = 0;
42659 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42660 wxItemKind result;
42661 void *argp1 = 0 ;
42662 int res1 = 0 ;
42663 PyObject *swig_obj[1] ;
42664
42665 if (!args) SWIG_fail;
42666 swig_obj[0] = args;
42667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42668 if (!SWIG_IsOK(res1)) {
42669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42670 }
42671 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42672 {
42673 PyThreadState* __tstate = wxPyBeginAllowThreads();
42674 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42675 wxPyEndAllowThreads(__tstate);
42676 if (PyErr_Occurred()) SWIG_fail;
42677 }
42678 resultobj = SWIG_From_int(static_cast< int >(result));
42679 return resultobj;
42680 fail:
42681 return NULL;
42682 }
42683
42684
42685 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42686 PyObject *resultobj = 0;
42687 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42688 wxItemKind arg2 ;
42689 void *argp1 = 0 ;
42690 int res1 = 0 ;
42691 int val2 ;
42692 int ecode2 = 0 ;
42693 PyObject * obj0 = 0 ;
42694 PyObject * obj1 = 0 ;
42695 char * kwnames[] = {
42696 (char *) "self",(char *) "kind", NULL
42697 };
42698
42699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42701 if (!SWIG_IsOK(res1)) {
42702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42703 }
42704 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42705 ecode2 = SWIG_AsVal_int(obj1, &val2);
42706 if (!SWIG_IsOK(ecode2)) {
42707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42708 }
42709 arg2 = static_cast< wxItemKind >(val2);
42710 {
42711 PyThreadState* __tstate = wxPyBeginAllowThreads();
42712 (arg1)->SetKind(arg2);
42713 wxPyEndAllowThreads(__tstate);
42714 if (PyErr_Occurred()) SWIG_fail;
42715 }
42716 resultobj = SWIG_Py_Void();
42717 return resultobj;
42718 fail:
42719 return NULL;
42720 }
42721
42722
42723 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42724 PyObject *resultobj = 0;
42725 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42726 bool arg2 ;
42727 void *argp1 = 0 ;
42728 int res1 = 0 ;
42729 bool val2 ;
42730 int ecode2 = 0 ;
42731 PyObject * obj0 = 0 ;
42732 PyObject * obj1 = 0 ;
42733 char * kwnames[] = {
42734 (char *) "self",(char *) "checkable", NULL
42735 };
42736
42737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42739 if (!SWIG_IsOK(res1)) {
42740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42741 }
42742 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42743 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42744 if (!SWIG_IsOK(ecode2)) {
42745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42746 }
42747 arg2 = static_cast< bool >(val2);
42748 {
42749 PyThreadState* __tstate = wxPyBeginAllowThreads();
42750 (arg1)->SetCheckable(arg2);
42751 wxPyEndAllowThreads(__tstate);
42752 if (PyErr_Occurred()) SWIG_fail;
42753 }
42754 resultobj = SWIG_Py_Void();
42755 return resultobj;
42756 fail:
42757 return NULL;
42758 }
42759
42760
42761 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42762 PyObject *resultobj = 0;
42763 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42764 bool result;
42765 void *argp1 = 0 ;
42766 int res1 = 0 ;
42767 PyObject *swig_obj[1] ;
42768
42769 if (!args) SWIG_fail;
42770 swig_obj[0] = args;
42771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42772 if (!SWIG_IsOK(res1)) {
42773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42774 }
42775 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42776 {
42777 PyThreadState* __tstate = wxPyBeginAllowThreads();
42778 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42779 wxPyEndAllowThreads(__tstate);
42780 if (PyErr_Occurred()) SWIG_fail;
42781 }
42782 {
42783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42784 }
42785 return resultobj;
42786 fail:
42787 return NULL;
42788 }
42789
42790
42791 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42792 PyObject *resultobj = 0;
42793 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42794 bool result;
42795 void *argp1 = 0 ;
42796 int res1 = 0 ;
42797 PyObject *swig_obj[1] ;
42798
42799 if (!args) SWIG_fail;
42800 swig_obj[0] = args;
42801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42802 if (!SWIG_IsOK(res1)) {
42803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42804 }
42805 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42806 {
42807 PyThreadState* __tstate = wxPyBeginAllowThreads();
42808 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42809 wxPyEndAllowThreads(__tstate);
42810 if (PyErr_Occurred()) SWIG_fail;
42811 }
42812 {
42813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42814 }
42815 return resultobj;
42816 fail:
42817 return NULL;
42818 }
42819
42820
42821 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42822 PyObject *resultobj = 0;
42823 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42824 wxMenu *arg2 = (wxMenu *) 0 ;
42825 void *argp1 = 0 ;
42826 int res1 = 0 ;
42827 void *argp2 = 0 ;
42828 int res2 = 0 ;
42829 PyObject * obj0 = 0 ;
42830 PyObject * obj1 = 0 ;
42831 char * kwnames[] = {
42832 (char *) "self",(char *) "menu", NULL
42833 };
42834
42835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42837 if (!SWIG_IsOK(res1)) {
42838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42839 }
42840 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42842 if (!SWIG_IsOK(res2)) {
42843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42844 }
42845 arg2 = reinterpret_cast< wxMenu * >(argp2);
42846 {
42847 PyThreadState* __tstate = wxPyBeginAllowThreads();
42848 (arg1)->SetSubMenu(arg2);
42849 wxPyEndAllowThreads(__tstate);
42850 if (PyErr_Occurred()) SWIG_fail;
42851 }
42852 resultobj = SWIG_Py_Void();
42853 return resultobj;
42854 fail:
42855 return NULL;
42856 }
42857
42858
42859 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42860 PyObject *resultobj = 0;
42861 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42862 wxMenu *result = 0 ;
42863 void *argp1 = 0 ;
42864 int res1 = 0 ;
42865 PyObject *swig_obj[1] ;
42866
42867 if (!args) SWIG_fail;
42868 swig_obj[0] = args;
42869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42870 if (!SWIG_IsOK(res1)) {
42871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42872 }
42873 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42874 {
42875 PyThreadState* __tstate = wxPyBeginAllowThreads();
42876 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42877 wxPyEndAllowThreads(__tstate);
42878 if (PyErr_Occurred()) SWIG_fail;
42879 }
42880 {
42881 resultobj = wxPyMake_wxObject(result, 0);
42882 }
42883 return resultobj;
42884 fail:
42885 return NULL;
42886 }
42887
42888
42889 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42890 PyObject *resultobj = 0;
42891 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42892 bool arg2 = (bool) true ;
42893 void *argp1 = 0 ;
42894 int res1 = 0 ;
42895 bool val2 ;
42896 int ecode2 = 0 ;
42897 PyObject * obj0 = 0 ;
42898 PyObject * obj1 = 0 ;
42899 char * kwnames[] = {
42900 (char *) "self",(char *) "enable", NULL
42901 };
42902
42903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42905 if (!SWIG_IsOK(res1)) {
42906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42907 }
42908 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42909 if (obj1) {
42910 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42911 if (!SWIG_IsOK(ecode2)) {
42912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42913 }
42914 arg2 = static_cast< bool >(val2);
42915 }
42916 {
42917 PyThreadState* __tstate = wxPyBeginAllowThreads();
42918 (arg1)->Enable(arg2);
42919 wxPyEndAllowThreads(__tstate);
42920 if (PyErr_Occurred()) SWIG_fail;
42921 }
42922 resultobj = SWIG_Py_Void();
42923 return resultobj;
42924 fail:
42925 return NULL;
42926 }
42927
42928
42929 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42930 PyObject *resultobj = 0;
42931 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42932 bool result;
42933 void *argp1 = 0 ;
42934 int res1 = 0 ;
42935 PyObject *swig_obj[1] ;
42936
42937 if (!args) SWIG_fail;
42938 swig_obj[0] = args;
42939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42940 if (!SWIG_IsOK(res1)) {
42941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42942 }
42943 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42944 {
42945 PyThreadState* __tstate = wxPyBeginAllowThreads();
42946 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42947 wxPyEndAllowThreads(__tstate);
42948 if (PyErr_Occurred()) SWIG_fail;
42949 }
42950 {
42951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42952 }
42953 return resultobj;
42954 fail:
42955 return NULL;
42956 }
42957
42958
42959 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42960 PyObject *resultobj = 0;
42961 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42962 bool arg2 = (bool) true ;
42963 void *argp1 = 0 ;
42964 int res1 = 0 ;
42965 bool val2 ;
42966 int ecode2 = 0 ;
42967 PyObject * obj0 = 0 ;
42968 PyObject * obj1 = 0 ;
42969 char * kwnames[] = {
42970 (char *) "self",(char *) "check", NULL
42971 };
42972
42973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42975 if (!SWIG_IsOK(res1)) {
42976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42977 }
42978 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42979 if (obj1) {
42980 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42981 if (!SWIG_IsOK(ecode2)) {
42982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42983 }
42984 arg2 = static_cast< bool >(val2);
42985 }
42986 {
42987 PyThreadState* __tstate = wxPyBeginAllowThreads();
42988 (arg1)->Check(arg2);
42989 wxPyEndAllowThreads(__tstate);
42990 if (PyErr_Occurred()) SWIG_fail;
42991 }
42992 resultobj = SWIG_Py_Void();
42993 return resultobj;
42994 fail:
42995 return NULL;
42996 }
42997
42998
42999 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43000 PyObject *resultobj = 0;
43001 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43002 bool result;
43003 void *argp1 = 0 ;
43004 int res1 = 0 ;
43005 PyObject *swig_obj[1] ;
43006
43007 if (!args) SWIG_fail;
43008 swig_obj[0] = args;
43009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43010 if (!SWIG_IsOK(res1)) {
43011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43012 }
43013 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43014 {
43015 PyThreadState* __tstate = wxPyBeginAllowThreads();
43016 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43017 wxPyEndAllowThreads(__tstate);
43018 if (PyErr_Occurred()) SWIG_fail;
43019 }
43020 {
43021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43022 }
43023 return resultobj;
43024 fail:
43025 return NULL;
43026 }
43027
43028
43029 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43030 PyObject *resultobj = 0;
43031 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43032 void *argp1 = 0 ;
43033 int res1 = 0 ;
43034 PyObject *swig_obj[1] ;
43035
43036 if (!args) SWIG_fail;
43037 swig_obj[0] = args;
43038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43039 if (!SWIG_IsOK(res1)) {
43040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43041 }
43042 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43043 {
43044 PyThreadState* __tstate = wxPyBeginAllowThreads();
43045 (arg1)->Toggle();
43046 wxPyEndAllowThreads(__tstate);
43047 if (PyErr_Occurred()) SWIG_fail;
43048 }
43049 resultobj = SWIG_Py_Void();
43050 return resultobj;
43051 fail:
43052 return NULL;
43053 }
43054
43055
43056 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43057 PyObject *resultobj = 0;
43058 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43059 wxString *arg2 = 0 ;
43060 void *argp1 = 0 ;
43061 int res1 = 0 ;
43062 bool temp2 = false ;
43063 PyObject * obj0 = 0 ;
43064 PyObject * obj1 = 0 ;
43065 char * kwnames[] = {
43066 (char *) "self",(char *) "str", NULL
43067 };
43068
43069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43071 if (!SWIG_IsOK(res1)) {
43072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43073 }
43074 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43075 {
43076 arg2 = wxString_in_helper(obj1);
43077 if (arg2 == NULL) SWIG_fail;
43078 temp2 = true;
43079 }
43080 {
43081 PyThreadState* __tstate = wxPyBeginAllowThreads();
43082 (arg1)->SetHelp((wxString const &)*arg2);
43083 wxPyEndAllowThreads(__tstate);
43084 if (PyErr_Occurred()) SWIG_fail;
43085 }
43086 resultobj = SWIG_Py_Void();
43087 {
43088 if (temp2)
43089 delete arg2;
43090 }
43091 return resultobj;
43092 fail:
43093 {
43094 if (temp2)
43095 delete arg2;
43096 }
43097 return NULL;
43098 }
43099
43100
43101 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43102 PyObject *resultobj = 0;
43103 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43104 wxString *result = 0 ;
43105 void *argp1 = 0 ;
43106 int res1 = 0 ;
43107 PyObject *swig_obj[1] ;
43108
43109 if (!args) SWIG_fail;
43110 swig_obj[0] = args;
43111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43112 if (!SWIG_IsOK(res1)) {
43113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43114 }
43115 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43116 {
43117 PyThreadState* __tstate = wxPyBeginAllowThreads();
43118 {
43119 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43120 result = (wxString *) &_result_ref;
43121 }
43122 wxPyEndAllowThreads(__tstate);
43123 if (PyErr_Occurred()) SWIG_fail;
43124 }
43125 {
43126 #if wxUSE_UNICODE
43127 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43128 #else
43129 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43130 #endif
43131 }
43132 return resultobj;
43133 fail:
43134 return NULL;
43135 }
43136
43137
43138 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43139 PyObject *resultobj = 0;
43140 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43141 wxAcceleratorEntry *result = 0 ;
43142 void *argp1 = 0 ;
43143 int res1 = 0 ;
43144 PyObject *swig_obj[1] ;
43145
43146 if (!args) SWIG_fail;
43147 swig_obj[0] = args;
43148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43149 if (!SWIG_IsOK(res1)) {
43150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43151 }
43152 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43153 {
43154 PyThreadState* __tstate = wxPyBeginAllowThreads();
43155 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43156 wxPyEndAllowThreads(__tstate);
43157 if (PyErr_Occurred()) SWIG_fail;
43158 }
43159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43160 return resultobj;
43161 fail:
43162 return NULL;
43163 }
43164
43165
43166 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43167 PyObject *resultobj = 0;
43168 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43169 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43170 void *argp1 = 0 ;
43171 int res1 = 0 ;
43172 void *argp2 = 0 ;
43173 int res2 = 0 ;
43174 PyObject * obj0 = 0 ;
43175 PyObject * obj1 = 0 ;
43176 char * kwnames[] = {
43177 (char *) "self",(char *) "accel", NULL
43178 };
43179
43180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43182 if (!SWIG_IsOK(res1)) {
43183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43184 }
43185 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43186 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43187 if (!SWIG_IsOK(res2)) {
43188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43189 }
43190 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43191 {
43192 PyThreadState* __tstate = wxPyBeginAllowThreads();
43193 (arg1)->SetAccel(arg2);
43194 wxPyEndAllowThreads(__tstate);
43195 if (PyErr_Occurred()) SWIG_fail;
43196 }
43197 resultobj = SWIG_Py_Void();
43198 return resultobj;
43199 fail:
43200 return NULL;
43201 }
43202
43203
43204 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43205 PyObject *resultobj = 0;
43206 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43207 wxBitmap *arg2 = 0 ;
43208 void *argp1 = 0 ;
43209 int res1 = 0 ;
43210 void *argp2 = 0 ;
43211 int res2 = 0 ;
43212 PyObject * obj0 = 0 ;
43213 PyObject * obj1 = 0 ;
43214 char * kwnames[] = {
43215 (char *) "self",(char *) "bitmap", NULL
43216 };
43217
43218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43220 if (!SWIG_IsOK(res1)) {
43221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43222 }
43223 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43224 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43225 if (!SWIG_IsOK(res2)) {
43226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43227 }
43228 if (!argp2) {
43229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43230 }
43231 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43232 {
43233 PyThreadState* __tstate = wxPyBeginAllowThreads();
43234 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43235 wxPyEndAllowThreads(__tstate);
43236 if (PyErr_Occurred()) SWIG_fail;
43237 }
43238 resultobj = SWIG_Py_Void();
43239 return resultobj;
43240 fail:
43241 return NULL;
43242 }
43243
43244
43245 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43246 PyObject *resultobj = 0;
43247 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43248 wxBitmap *result = 0 ;
43249 void *argp1 = 0 ;
43250 int res1 = 0 ;
43251 PyObject *swig_obj[1] ;
43252
43253 if (!args) SWIG_fail;
43254 swig_obj[0] = args;
43255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43256 if (!SWIG_IsOK(res1)) {
43257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43258 }
43259 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43260 {
43261 PyThreadState* __tstate = wxPyBeginAllowThreads();
43262 {
43263 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43264 result = (wxBitmap *) &_result_ref;
43265 }
43266 wxPyEndAllowThreads(__tstate);
43267 if (PyErr_Occurred()) SWIG_fail;
43268 }
43269 {
43270 wxBitmap* resultptr = new wxBitmap(*result);
43271 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43272 }
43273 return resultobj;
43274 fail:
43275 return NULL;
43276 }
43277
43278
43279 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43280 PyObject *resultobj = 0;
43281 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43282 wxFont *arg2 = 0 ;
43283 void *argp1 = 0 ;
43284 int res1 = 0 ;
43285 void *argp2 = 0 ;
43286 int res2 = 0 ;
43287 PyObject * obj0 = 0 ;
43288 PyObject * obj1 = 0 ;
43289 char * kwnames[] = {
43290 (char *) "self",(char *) "font", NULL
43291 };
43292
43293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43295 if (!SWIG_IsOK(res1)) {
43296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43297 }
43298 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43299 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43300 if (!SWIG_IsOK(res2)) {
43301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43302 }
43303 if (!argp2) {
43304 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43305 }
43306 arg2 = reinterpret_cast< wxFont * >(argp2);
43307 {
43308 PyThreadState* __tstate = wxPyBeginAllowThreads();
43309 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43310 wxPyEndAllowThreads(__tstate);
43311 if (PyErr_Occurred()) SWIG_fail;
43312 }
43313 resultobj = SWIG_Py_Void();
43314 return resultobj;
43315 fail:
43316 return NULL;
43317 }
43318
43319
43320 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43321 PyObject *resultobj = 0;
43322 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43323 wxFont result;
43324 void *argp1 = 0 ;
43325 int res1 = 0 ;
43326 PyObject *swig_obj[1] ;
43327
43328 if (!args) SWIG_fail;
43329 swig_obj[0] = args;
43330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43331 if (!SWIG_IsOK(res1)) {
43332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43333 }
43334 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43335 {
43336 PyThreadState* __tstate = wxPyBeginAllowThreads();
43337 result = wxMenuItem_GetFont(arg1);
43338 wxPyEndAllowThreads(__tstate);
43339 if (PyErr_Occurred()) SWIG_fail;
43340 }
43341 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43342 return resultobj;
43343 fail:
43344 return NULL;
43345 }
43346
43347
43348 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43349 PyObject *resultobj = 0;
43350 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43351 wxColour *arg2 = 0 ;
43352 void *argp1 = 0 ;
43353 int res1 = 0 ;
43354 wxColour temp2 ;
43355 PyObject * obj0 = 0 ;
43356 PyObject * obj1 = 0 ;
43357 char * kwnames[] = {
43358 (char *) "self",(char *) "colText", NULL
43359 };
43360
43361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43363 if (!SWIG_IsOK(res1)) {
43364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43365 }
43366 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43367 {
43368 arg2 = &temp2;
43369 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43370 }
43371 {
43372 PyThreadState* __tstate = wxPyBeginAllowThreads();
43373 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43374 wxPyEndAllowThreads(__tstate);
43375 if (PyErr_Occurred()) SWIG_fail;
43376 }
43377 resultobj = SWIG_Py_Void();
43378 return resultobj;
43379 fail:
43380 return NULL;
43381 }
43382
43383
43384 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43385 PyObject *resultobj = 0;
43386 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43387 wxColour result;
43388 void *argp1 = 0 ;
43389 int res1 = 0 ;
43390 PyObject *swig_obj[1] ;
43391
43392 if (!args) SWIG_fail;
43393 swig_obj[0] = args;
43394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43395 if (!SWIG_IsOK(res1)) {
43396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43397 }
43398 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43399 {
43400 PyThreadState* __tstate = wxPyBeginAllowThreads();
43401 result = wxMenuItem_GetTextColour(arg1);
43402 wxPyEndAllowThreads(__tstate);
43403 if (PyErr_Occurred()) SWIG_fail;
43404 }
43405 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43406 return resultobj;
43407 fail:
43408 return NULL;
43409 }
43410
43411
43412 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43413 PyObject *resultobj = 0;
43414 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43415 wxColour *arg2 = 0 ;
43416 void *argp1 = 0 ;
43417 int res1 = 0 ;
43418 wxColour temp2 ;
43419 PyObject * obj0 = 0 ;
43420 PyObject * obj1 = 0 ;
43421 char * kwnames[] = {
43422 (char *) "self",(char *) "colBack", NULL
43423 };
43424
43425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43427 if (!SWIG_IsOK(res1)) {
43428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43429 }
43430 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43431 {
43432 arg2 = &temp2;
43433 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43434 }
43435 {
43436 PyThreadState* __tstate = wxPyBeginAllowThreads();
43437 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43438 wxPyEndAllowThreads(__tstate);
43439 if (PyErr_Occurred()) SWIG_fail;
43440 }
43441 resultobj = SWIG_Py_Void();
43442 return resultobj;
43443 fail:
43444 return NULL;
43445 }
43446
43447
43448 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43449 PyObject *resultobj = 0;
43450 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43451 wxColour result;
43452 void *argp1 = 0 ;
43453 int res1 = 0 ;
43454 PyObject *swig_obj[1] ;
43455
43456 if (!args) SWIG_fail;
43457 swig_obj[0] = args;
43458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43459 if (!SWIG_IsOK(res1)) {
43460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43461 }
43462 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43463 {
43464 PyThreadState* __tstate = wxPyBeginAllowThreads();
43465 result = wxMenuItem_GetBackgroundColour(arg1);
43466 wxPyEndAllowThreads(__tstate);
43467 if (PyErr_Occurred()) SWIG_fail;
43468 }
43469 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43470 return resultobj;
43471 fail:
43472 return NULL;
43473 }
43474
43475
43476 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43477 PyObject *resultobj = 0;
43478 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43479 wxBitmap *arg2 = 0 ;
43480 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43481 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43482 void *argp1 = 0 ;
43483 int res1 = 0 ;
43484 void *argp2 = 0 ;
43485 int res2 = 0 ;
43486 void *argp3 = 0 ;
43487 int res3 = 0 ;
43488 PyObject * obj0 = 0 ;
43489 PyObject * obj1 = 0 ;
43490 PyObject * obj2 = 0 ;
43491 char * kwnames[] = {
43492 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43493 };
43494
43495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43497 if (!SWIG_IsOK(res1)) {
43498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43499 }
43500 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43501 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43502 if (!SWIG_IsOK(res2)) {
43503 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43504 }
43505 if (!argp2) {
43506 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43507 }
43508 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43509 if (obj2) {
43510 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43511 if (!SWIG_IsOK(res3)) {
43512 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43513 }
43514 if (!argp3) {
43515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43516 }
43517 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43518 }
43519 {
43520 PyThreadState* __tstate = wxPyBeginAllowThreads();
43521 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43522 wxPyEndAllowThreads(__tstate);
43523 if (PyErr_Occurred()) SWIG_fail;
43524 }
43525 resultobj = SWIG_Py_Void();
43526 return resultobj;
43527 fail:
43528 return NULL;
43529 }
43530
43531
43532 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43533 PyObject *resultobj = 0;
43534 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43535 wxBitmap *arg2 = 0 ;
43536 void *argp1 = 0 ;
43537 int res1 = 0 ;
43538 void *argp2 = 0 ;
43539 int res2 = 0 ;
43540 PyObject * obj0 = 0 ;
43541 PyObject * obj1 = 0 ;
43542 char * kwnames[] = {
43543 (char *) "self",(char *) "bmpDisabled", NULL
43544 };
43545
43546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43548 if (!SWIG_IsOK(res1)) {
43549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43550 }
43551 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43552 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43553 if (!SWIG_IsOK(res2)) {
43554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43555 }
43556 if (!argp2) {
43557 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43558 }
43559 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43560 {
43561 PyThreadState* __tstate = wxPyBeginAllowThreads();
43562 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43563 wxPyEndAllowThreads(__tstate);
43564 if (PyErr_Occurred()) SWIG_fail;
43565 }
43566 resultobj = SWIG_Py_Void();
43567 return resultobj;
43568 fail:
43569 return NULL;
43570 }
43571
43572
43573 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43574 PyObject *resultobj = 0;
43575 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43576 wxBitmap *result = 0 ;
43577 void *argp1 = 0 ;
43578 int res1 = 0 ;
43579 PyObject *swig_obj[1] ;
43580
43581 if (!args) SWIG_fail;
43582 swig_obj[0] = args;
43583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43584 if (!SWIG_IsOK(res1)) {
43585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43586 }
43587 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43588 {
43589 PyThreadState* __tstate = wxPyBeginAllowThreads();
43590 {
43591 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43592 result = (wxBitmap *) &_result_ref;
43593 }
43594 wxPyEndAllowThreads(__tstate);
43595 if (PyErr_Occurred()) SWIG_fail;
43596 }
43597 {
43598 wxBitmap* resultptr = new wxBitmap(*result);
43599 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43600 }
43601 return resultobj;
43602 fail:
43603 return NULL;
43604 }
43605
43606
43607 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43608 PyObject *resultobj = 0;
43609 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43610 int arg2 ;
43611 void *argp1 = 0 ;
43612 int res1 = 0 ;
43613 int val2 ;
43614 int ecode2 = 0 ;
43615 PyObject * obj0 = 0 ;
43616 PyObject * obj1 = 0 ;
43617 char * kwnames[] = {
43618 (char *) "self",(char *) "nWidth", NULL
43619 };
43620
43621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43623 if (!SWIG_IsOK(res1)) {
43624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43625 }
43626 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43627 ecode2 = SWIG_AsVal_int(obj1, &val2);
43628 if (!SWIG_IsOK(ecode2)) {
43629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43630 }
43631 arg2 = static_cast< int >(val2);
43632 {
43633 PyThreadState* __tstate = wxPyBeginAllowThreads();
43634 wxMenuItem_SetMarginWidth(arg1,arg2);
43635 wxPyEndAllowThreads(__tstate);
43636 if (PyErr_Occurred()) SWIG_fail;
43637 }
43638 resultobj = SWIG_Py_Void();
43639 return resultobj;
43640 fail:
43641 return NULL;
43642 }
43643
43644
43645 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43646 PyObject *resultobj = 0;
43647 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43648 int result;
43649 void *argp1 = 0 ;
43650 int res1 = 0 ;
43651 PyObject *swig_obj[1] ;
43652
43653 if (!args) SWIG_fail;
43654 swig_obj[0] = args;
43655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43656 if (!SWIG_IsOK(res1)) {
43657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43658 }
43659 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43660 {
43661 PyThreadState* __tstate = wxPyBeginAllowThreads();
43662 result = (int)wxMenuItem_GetMarginWidth(arg1);
43663 wxPyEndAllowThreads(__tstate);
43664 if (PyErr_Occurred()) SWIG_fail;
43665 }
43666 resultobj = SWIG_From_int(static_cast< int >(result));
43667 return resultobj;
43668 fail:
43669 return NULL;
43670 }
43671
43672
43673 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43674 PyObject *resultobj = 0;
43675 int result;
43676
43677 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43678 {
43679 PyThreadState* __tstate = wxPyBeginAllowThreads();
43680 result = (int)wxMenuItem_GetDefaultMarginWidth();
43681 wxPyEndAllowThreads(__tstate);
43682 if (PyErr_Occurred()) SWIG_fail;
43683 }
43684 resultobj = SWIG_From_int(static_cast< int >(result));
43685 return resultobj;
43686 fail:
43687 return NULL;
43688 }
43689
43690
43691 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43692 PyObject *resultobj = 0;
43693 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43694 bool result;
43695 void *argp1 = 0 ;
43696 int res1 = 0 ;
43697 PyObject *swig_obj[1] ;
43698
43699 if (!args) SWIG_fail;
43700 swig_obj[0] = args;
43701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43702 if (!SWIG_IsOK(res1)) {
43703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43704 }
43705 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43706 {
43707 PyThreadState* __tstate = wxPyBeginAllowThreads();
43708 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43709 wxPyEndAllowThreads(__tstate);
43710 if (PyErr_Occurred()) SWIG_fail;
43711 }
43712 {
43713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43714 }
43715 return resultobj;
43716 fail:
43717 return NULL;
43718 }
43719
43720
43721 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43722 PyObject *resultobj = 0;
43723 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43724 bool arg2 = (bool) true ;
43725 void *argp1 = 0 ;
43726 int res1 = 0 ;
43727 bool val2 ;
43728 int ecode2 = 0 ;
43729 PyObject * obj0 = 0 ;
43730 PyObject * obj1 = 0 ;
43731 char * kwnames[] = {
43732 (char *) "self",(char *) "ownerDrawn", NULL
43733 };
43734
43735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43737 if (!SWIG_IsOK(res1)) {
43738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43739 }
43740 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43741 if (obj1) {
43742 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43743 if (!SWIG_IsOK(ecode2)) {
43744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43745 }
43746 arg2 = static_cast< bool >(val2);
43747 }
43748 {
43749 PyThreadState* __tstate = wxPyBeginAllowThreads();
43750 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43751 wxPyEndAllowThreads(__tstate);
43752 if (PyErr_Occurred()) SWIG_fail;
43753 }
43754 resultobj = SWIG_Py_Void();
43755 return resultobj;
43756 fail:
43757 return NULL;
43758 }
43759
43760
43761 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43762 PyObject *resultobj = 0;
43763 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43764 void *argp1 = 0 ;
43765 int res1 = 0 ;
43766 PyObject *swig_obj[1] ;
43767
43768 if (!args) SWIG_fail;
43769 swig_obj[0] = args;
43770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43771 if (!SWIG_IsOK(res1)) {
43772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43773 }
43774 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43775 {
43776 PyThreadState* __tstate = wxPyBeginAllowThreads();
43777 wxMenuItem_ResetOwnerDrawn(arg1);
43778 wxPyEndAllowThreads(__tstate);
43779 if (PyErr_Occurred()) SWIG_fail;
43780 }
43781 resultobj = SWIG_Py_Void();
43782 return resultobj;
43783 fail:
43784 return NULL;
43785 }
43786
43787
43788 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43789 PyObject *obj;
43790 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43791 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43792 return SWIG_Py_Void();
43793 }
43794
43795 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43796 return SWIG_Python_InitShadowInstance(args);
43797 }
43798
43799 SWIGINTERN int ControlNameStr_set(PyObject *) {
43800 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43801 return 1;
43802 }
43803
43804
43805 SWIGINTERN PyObject *ControlNameStr_get(void) {
43806 PyObject *pyobj = 0;
43807
43808 {
43809 #if wxUSE_UNICODE
43810 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43811 #else
43812 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43813 #endif
43814 }
43815 return pyobj;
43816 }
43817
43818
43819 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43820 PyObject *resultobj = 0;
43821 wxWindow *arg1 = (wxWindow *) 0 ;
43822 int arg2 = (int) -1 ;
43823 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43824 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43825 wxSize const &arg4_defvalue = wxDefaultSize ;
43826 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43827 long arg5 = (long) 0 ;
43828 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43829 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43830 wxString const &arg7_defvalue = wxPyControlNameStr ;
43831 wxString *arg7 = (wxString *) &arg7_defvalue ;
43832 wxControl *result = 0 ;
43833 void *argp1 = 0 ;
43834 int res1 = 0 ;
43835 int val2 ;
43836 int ecode2 = 0 ;
43837 wxPoint temp3 ;
43838 wxSize temp4 ;
43839 long val5 ;
43840 int ecode5 = 0 ;
43841 void *argp6 = 0 ;
43842 int res6 = 0 ;
43843 bool temp7 = false ;
43844 PyObject * obj0 = 0 ;
43845 PyObject * obj1 = 0 ;
43846 PyObject * obj2 = 0 ;
43847 PyObject * obj3 = 0 ;
43848 PyObject * obj4 = 0 ;
43849 PyObject * obj5 = 0 ;
43850 PyObject * obj6 = 0 ;
43851 char * kwnames[] = {
43852 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43853 };
43854
43855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43857 if (!SWIG_IsOK(res1)) {
43858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43859 }
43860 arg1 = reinterpret_cast< wxWindow * >(argp1);
43861 if (obj1) {
43862 ecode2 = SWIG_AsVal_int(obj1, &val2);
43863 if (!SWIG_IsOK(ecode2)) {
43864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43865 }
43866 arg2 = static_cast< int >(val2);
43867 }
43868 if (obj2) {
43869 {
43870 arg3 = &temp3;
43871 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43872 }
43873 }
43874 if (obj3) {
43875 {
43876 arg4 = &temp4;
43877 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43878 }
43879 }
43880 if (obj4) {
43881 ecode5 = SWIG_AsVal_long(obj4, &val5);
43882 if (!SWIG_IsOK(ecode5)) {
43883 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43884 }
43885 arg5 = static_cast< long >(val5);
43886 }
43887 if (obj5) {
43888 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43889 if (!SWIG_IsOK(res6)) {
43890 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43891 }
43892 if (!argp6) {
43893 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43894 }
43895 arg6 = reinterpret_cast< wxValidator * >(argp6);
43896 }
43897 if (obj6) {
43898 {
43899 arg7 = wxString_in_helper(obj6);
43900 if (arg7 == NULL) SWIG_fail;
43901 temp7 = true;
43902 }
43903 }
43904 {
43905 if (!wxPyCheckForApp()) SWIG_fail;
43906 PyThreadState* __tstate = wxPyBeginAllowThreads();
43907 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43908 wxPyEndAllowThreads(__tstate);
43909 if (PyErr_Occurred()) SWIG_fail;
43910 }
43911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43912 {
43913 if (temp7)
43914 delete arg7;
43915 }
43916 return resultobj;
43917 fail:
43918 {
43919 if (temp7)
43920 delete arg7;
43921 }
43922 return NULL;
43923 }
43924
43925
43926 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43927 PyObject *resultobj = 0;
43928 wxControl *result = 0 ;
43929
43930 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43931 {
43932 if (!wxPyCheckForApp()) SWIG_fail;
43933 PyThreadState* __tstate = wxPyBeginAllowThreads();
43934 result = (wxControl *)new wxControl();
43935 wxPyEndAllowThreads(__tstate);
43936 if (PyErr_Occurred()) SWIG_fail;
43937 }
43938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43939 return resultobj;
43940 fail:
43941 return NULL;
43942 }
43943
43944
43945 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43946 PyObject *resultobj = 0;
43947 wxControl *arg1 = (wxControl *) 0 ;
43948 wxWindow *arg2 = (wxWindow *) 0 ;
43949 int arg3 = (int) -1 ;
43950 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43951 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43952 wxSize const &arg5_defvalue = wxDefaultSize ;
43953 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43954 long arg6 = (long) 0 ;
43955 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43956 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43957 wxString const &arg8_defvalue = wxPyControlNameStr ;
43958 wxString *arg8 = (wxString *) &arg8_defvalue ;
43959 bool result;
43960 void *argp1 = 0 ;
43961 int res1 = 0 ;
43962 void *argp2 = 0 ;
43963 int res2 = 0 ;
43964 int val3 ;
43965 int ecode3 = 0 ;
43966 wxPoint temp4 ;
43967 wxSize temp5 ;
43968 long val6 ;
43969 int ecode6 = 0 ;
43970 void *argp7 = 0 ;
43971 int res7 = 0 ;
43972 bool temp8 = false ;
43973 PyObject * obj0 = 0 ;
43974 PyObject * obj1 = 0 ;
43975 PyObject * obj2 = 0 ;
43976 PyObject * obj3 = 0 ;
43977 PyObject * obj4 = 0 ;
43978 PyObject * obj5 = 0 ;
43979 PyObject * obj6 = 0 ;
43980 PyObject * obj7 = 0 ;
43981 char * kwnames[] = {
43982 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43983 };
43984
43985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43987 if (!SWIG_IsOK(res1)) {
43988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43989 }
43990 arg1 = reinterpret_cast< wxControl * >(argp1);
43991 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43992 if (!SWIG_IsOK(res2)) {
43993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43994 }
43995 arg2 = reinterpret_cast< wxWindow * >(argp2);
43996 if (obj2) {
43997 ecode3 = SWIG_AsVal_int(obj2, &val3);
43998 if (!SWIG_IsOK(ecode3)) {
43999 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44000 }
44001 arg3 = static_cast< int >(val3);
44002 }
44003 if (obj3) {
44004 {
44005 arg4 = &temp4;
44006 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44007 }
44008 }
44009 if (obj4) {
44010 {
44011 arg5 = &temp5;
44012 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44013 }
44014 }
44015 if (obj5) {
44016 ecode6 = SWIG_AsVal_long(obj5, &val6);
44017 if (!SWIG_IsOK(ecode6)) {
44018 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44019 }
44020 arg6 = static_cast< long >(val6);
44021 }
44022 if (obj6) {
44023 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44024 if (!SWIG_IsOK(res7)) {
44025 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44026 }
44027 if (!argp7) {
44028 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44029 }
44030 arg7 = reinterpret_cast< wxValidator * >(argp7);
44031 }
44032 if (obj7) {
44033 {
44034 arg8 = wxString_in_helper(obj7);
44035 if (arg8 == NULL) SWIG_fail;
44036 temp8 = true;
44037 }
44038 }
44039 {
44040 PyThreadState* __tstate = wxPyBeginAllowThreads();
44041 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44042 wxPyEndAllowThreads(__tstate);
44043 if (PyErr_Occurred()) SWIG_fail;
44044 }
44045 {
44046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44047 }
44048 {
44049 if (temp8)
44050 delete arg8;
44051 }
44052 return resultobj;
44053 fail:
44054 {
44055 if (temp8)
44056 delete arg8;
44057 }
44058 return NULL;
44059 }
44060
44061
44062 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44063 PyObject *resultobj = 0;
44064 wxControl *arg1 = (wxControl *) 0 ;
44065 wxCommandEvent *arg2 = 0 ;
44066 void *argp1 = 0 ;
44067 int res1 = 0 ;
44068 void *argp2 = 0 ;
44069 int res2 = 0 ;
44070 PyObject * obj0 = 0 ;
44071 PyObject * obj1 = 0 ;
44072 char * kwnames[] = {
44073 (char *) "self",(char *) "event", NULL
44074 };
44075
44076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44078 if (!SWIG_IsOK(res1)) {
44079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44080 }
44081 arg1 = reinterpret_cast< wxControl * >(argp1);
44082 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44083 if (!SWIG_IsOK(res2)) {
44084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44085 }
44086 if (!argp2) {
44087 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44088 }
44089 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44090 {
44091 PyThreadState* __tstate = wxPyBeginAllowThreads();
44092 (arg1)->Command(*arg2);
44093 wxPyEndAllowThreads(__tstate);
44094 if (PyErr_Occurred()) SWIG_fail;
44095 }
44096 resultobj = SWIG_Py_Void();
44097 return resultobj;
44098 fail:
44099 return NULL;
44100 }
44101
44102
44103 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44104 PyObject *resultobj = 0;
44105 wxControl *arg1 = (wxControl *) 0 ;
44106 wxString result;
44107 void *argp1 = 0 ;
44108 int res1 = 0 ;
44109 PyObject *swig_obj[1] ;
44110
44111 if (!args) SWIG_fail;
44112 swig_obj[0] = args;
44113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44114 if (!SWIG_IsOK(res1)) {
44115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44116 }
44117 arg1 = reinterpret_cast< wxControl * >(argp1);
44118 {
44119 PyThreadState* __tstate = wxPyBeginAllowThreads();
44120 result = (arg1)->GetLabel();
44121 wxPyEndAllowThreads(__tstate);
44122 if (PyErr_Occurred()) SWIG_fail;
44123 }
44124 {
44125 #if wxUSE_UNICODE
44126 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44127 #else
44128 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44129 #endif
44130 }
44131 return resultobj;
44132 fail:
44133 return NULL;
44134 }
44135
44136
44137 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44138 PyObject *resultobj = 0;
44139 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44140 SwigValueWrapper<wxVisualAttributes > result;
44141 int val1 ;
44142 int ecode1 = 0 ;
44143 PyObject * obj0 = 0 ;
44144 char * kwnames[] = {
44145 (char *) "variant", NULL
44146 };
44147
44148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44149 if (obj0) {
44150 ecode1 = SWIG_AsVal_int(obj0, &val1);
44151 if (!SWIG_IsOK(ecode1)) {
44152 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44153 }
44154 arg1 = static_cast< wxWindowVariant >(val1);
44155 }
44156 {
44157 if (!wxPyCheckForApp()) SWIG_fail;
44158 PyThreadState* __tstate = wxPyBeginAllowThreads();
44159 result = wxControl::GetClassDefaultAttributes(arg1);
44160 wxPyEndAllowThreads(__tstate);
44161 if (PyErr_Occurred()) SWIG_fail;
44162 }
44163 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44164 return resultobj;
44165 fail:
44166 return NULL;
44167 }
44168
44169
44170 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44171 PyObject *obj;
44172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44173 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44174 return SWIG_Py_Void();
44175 }
44176
44177 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44178 return SWIG_Python_InitShadowInstance(args);
44179 }
44180
44181 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44182 PyObject *resultobj = 0;
44183 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44184 wxString *arg2 = 0 ;
44185 PyObject *arg3 = (PyObject *) NULL ;
44186 int result;
44187 void *argp1 = 0 ;
44188 int res1 = 0 ;
44189 bool temp2 = false ;
44190 PyObject * obj0 = 0 ;
44191 PyObject * obj1 = 0 ;
44192 PyObject * obj2 = 0 ;
44193 char * kwnames[] = {
44194 (char *) "self",(char *) "item",(char *) "clientData", NULL
44195 };
44196
44197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44199 if (!SWIG_IsOK(res1)) {
44200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44201 }
44202 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44203 {
44204 arg2 = wxString_in_helper(obj1);
44205 if (arg2 == NULL) SWIG_fail;
44206 temp2 = true;
44207 }
44208 if (obj2) {
44209 arg3 = obj2;
44210 }
44211 {
44212 PyThreadState* __tstate = wxPyBeginAllowThreads();
44213 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44214 wxPyEndAllowThreads(__tstate);
44215 if (PyErr_Occurred()) SWIG_fail;
44216 }
44217 resultobj = SWIG_From_int(static_cast< int >(result));
44218 {
44219 if (temp2)
44220 delete arg2;
44221 }
44222 return resultobj;
44223 fail:
44224 {
44225 if (temp2)
44226 delete arg2;
44227 }
44228 return NULL;
44229 }
44230
44231
44232 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44233 PyObject *resultobj = 0;
44234 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44235 wxArrayString *arg2 = 0 ;
44236 void *argp1 = 0 ;
44237 int res1 = 0 ;
44238 bool temp2 = false ;
44239 PyObject * obj0 = 0 ;
44240 PyObject * obj1 = 0 ;
44241 char * kwnames[] = {
44242 (char *) "self",(char *) "strings", NULL
44243 };
44244
44245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44247 if (!SWIG_IsOK(res1)) {
44248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44249 }
44250 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44251 {
44252 if (! PySequence_Check(obj1)) {
44253 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44254 SWIG_fail;
44255 }
44256 arg2 = new wxArrayString;
44257 temp2 = true;
44258 int i, len=PySequence_Length(obj1);
44259 for (i=0; i<len; i++) {
44260 PyObject* item = PySequence_GetItem(obj1, i);
44261 wxString* s = wxString_in_helper(item);
44262 if (PyErr_Occurred()) SWIG_fail;
44263 arg2->Add(*s);
44264 delete s;
44265 Py_DECREF(item);
44266 }
44267 }
44268 {
44269 PyThreadState* __tstate = wxPyBeginAllowThreads();
44270 (arg1)->Append((wxArrayString const &)*arg2);
44271 wxPyEndAllowThreads(__tstate);
44272 if (PyErr_Occurred()) SWIG_fail;
44273 }
44274 resultobj = SWIG_Py_Void();
44275 {
44276 if (temp2) delete arg2;
44277 }
44278 return resultobj;
44279 fail:
44280 {
44281 if (temp2) delete arg2;
44282 }
44283 return NULL;
44284 }
44285
44286
44287 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44288 PyObject *resultobj = 0;
44289 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44290 wxString *arg2 = 0 ;
44291 unsigned int arg3 ;
44292 PyObject *arg4 = (PyObject *) NULL ;
44293 int result;
44294 void *argp1 = 0 ;
44295 int res1 = 0 ;
44296 bool temp2 = false ;
44297 unsigned int val3 ;
44298 int ecode3 = 0 ;
44299 PyObject * obj0 = 0 ;
44300 PyObject * obj1 = 0 ;
44301 PyObject * obj2 = 0 ;
44302 PyObject * obj3 = 0 ;
44303 char * kwnames[] = {
44304 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44305 };
44306
44307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44309 if (!SWIG_IsOK(res1)) {
44310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44311 }
44312 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44313 {
44314 arg2 = wxString_in_helper(obj1);
44315 if (arg2 == NULL) SWIG_fail;
44316 temp2 = true;
44317 }
44318 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44319 if (!SWIG_IsOK(ecode3)) {
44320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44321 }
44322 arg3 = static_cast< unsigned int >(val3);
44323 if (obj3) {
44324 arg4 = obj3;
44325 }
44326 {
44327 PyThreadState* __tstate = wxPyBeginAllowThreads();
44328 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44329 wxPyEndAllowThreads(__tstate);
44330 if (PyErr_Occurred()) SWIG_fail;
44331 }
44332 resultobj = SWIG_From_int(static_cast< int >(result));
44333 {
44334 if (temp2)
44335 delete arg2;
44336 }
44337 return resultobj;
44338 fail:
44339 {
44340 if (temp2)
44341 delete arg2;
44342 }
44343 return NULL;
44344 }
44345
44346
44347 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44348 PyObject *resultobj = 0;
44349 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44350 void *argp1 = 0 ;
44351 int res1 = 0 ;
44352 PyObject *swig_obj[1] ;
44353
44354 if (!args) SWIG_fail;
44355 swig_obj[0] = args;
44356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44357 if (!SWIG_IsOK(res1)) {
44358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44359 }
44360 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44361 {
44362 PyThreadState* __tstate = wxPyBeginAllowThreads();
44363 (arg1)->Clear();
44364 wxPyEndAllowThreads(__tstate);
44365 if (PyErr_Occurred()) SWIG_fail;
44366 }
44367 resultobj = SWIG_Py_Void();
44368 return resultobj;
44369 fail:
44370 return NULL;
44371 }
44372
44373
44374 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44375 PyObject *resultobj = 0;
44376 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44377 unsigned int arg2 ;
44378 void *argp1 = 0 ;
44379 int res1 = 0 ;
44380 unsigned int val2 ;
44381 int ecode2 = 0 ;
44382 PyObject * obj0 = 0 ;
44383 PyObject * obj1 = 0 ;
44384 char * kwnames[] = {
44385 (char *) "self",(char *) "n", NULL
44386 };
44387
44388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44390 if (!SWIG_IsOK(res1)) {
44391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44392 }
44393 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44394 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44395 if (!SWIG_IsOK(ecode2)) {
44396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44397 }
44398 arg2 = static_cast< unsigned int >(val2);
44399 {
44400 PyThreadState* __tstate = wxPyBeginAllowThreads();
44401 (arg1)->Delete(arg2);
44402 wxPyEndAllowThreads(__tstate);
44403 if (PyErr_Occurred()) SWIG_fail;
44404 }
44405 resultobj = SWIG_Py_Void();
44406 return resultobj;
44407 fail:
44408 return NULL;
44409 }
44410
44411
44412 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44413 PyObject *resultobj = 0;
44414 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44415 unsigned int arg2 ;
44416 PyObject *result = 0 ;
44417 void *argp1 = 0 ;
44418 int res1 = 0 ;
44419 unsigned int val2 ;
44420 int ecode2 = 0 ;
44421 PyObject * obj0 = 0 ;
44422 PyObject * obj1 = 0 ;
44423 char * kwnames[] = {
44424 (char *) "self",(char *) "n", NULL
44425 };
44426
44427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44429 if (!SWIG_IsOK(res1)) {
44430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44431 }
44432 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44433 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44434 if (!SWIG_IsOK(ecode2)) {
44435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44436 }
44437 arg2 = static_cast< unsigned int >(val2);
44438 {
44439 PyThreadState* __tstate = wxPyBeginAllowThreads();
44440 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44441 wxPyEndAllowThreads(__tstate);
44442 if (PyErr_Occurred()) SWIG_fail;
44443 }
44444 resultobj = result;
44445 return resultobj;
44446 fail:
44447 return NULL;
44448 }
44449
44450
44451 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44452 PyObject *resultobj = 0;
44453 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44454 unsigned int arg2 ;
44455 PyObject *arg3 = (PyObject *) 0 ;
44456 void *argp1 = 0 ;
44457 int res1 = 0 ;
44458 unsigned int val2 ;
44459 int ecode2 = 0 ;
44460 PyObject * obj0 = 0 ;
44461 PyObject * obj1 = 0 ;
44462 PyObject * obj2 = 0 ;
44463 char * kwnames[] = {
44464 (char *) "self",(char *) "n",(char *) "clientData", NULL
44465 };
44466
44467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44469 if (!SWIG_IsOK(res1)) {
44470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44471 }
44472 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44473 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44474 if (!SWIG_IsOK(ecode2)) {
44475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44476 }
44477 arg2 = static_cast< unsigned int >(val2);
44478 arg3 = obj2;
44479 {
44480 PyThreadState* __tstate = wxPyBeginAllowThreads();
44481 wxItemContainer_SetClientData(arg1,arg2,arg3);
44482 wxPyEndAllowThreads(__tstate);
44483 if (PyErr_Occurred()) SWIG_fail;
44484 }
44485 resultobj = SWIG_Py_Void();
44486 return resultobj;
44487 fail:
44488 return NULL;
44489 }
44490
44491
44492 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44493 PyObject *resultobj = 0;
44494 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44495 unsigned int result;
44496 void *argp1 = 0 ;
44497 int res1 = 0 ;
44498 PyObject *swig_obj[1] ;
44499
44500 if (!args) SWIG_fail;
44501 swig_obj[0] = args;
44502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44503 if (!SWIG_IsOK(res1)) {
44504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44505 }
44506 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44507 {
44508 PyThreadState* __tstate = wxPyBeginAllowThreads();
44509 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44510 wxPyEndAllowThreads(__tstate);
44511 if (PyErr_Occurred()) SWIG_fail;
44512 }
44513 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44514 return resultobj;
44515 fail:
44516 return NULL;
44517 }
44518
44519
44520 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44521 PyObject *resultobj = 0;
44522 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44523 bool result;
44524 void *argp1 = 0 ;
44525 int res1 = 0 ;
44526 PyObject *swig_obj[1] ;
44527
44528 if (!args) SWIG_fail;
44529 swig_obj[0] = args;
44530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44531 if (!SWIG_IsOK(res1)) {
44532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44533 }
44534 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44535 {
44536 PyThreadState* __tstate = wxPyBeginAllowThreads();
44537 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44538 wxPyEndAllowThreads(__tstate);
44539 if (PyErr_Occurred()) SWIG_fail;
44540 }
44541 {
44542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44543 }
44544 return resultobj;
44545 fail:
44546 return NULL;
44547 }
44548
44549
44550 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44551 PyObject *resultobj = 0;
44552 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44553 unsigned int arg2 ;
44554 wxString result;
44555 void *argp1 = 0 ;
44556 int res1 = 0 ;
44557 unsigned int val2 ;
44558 int ecode2 = 0 ;
44559 PyObject * obj0 = 0 ;
44560 PyObject * obj1 = 0 ;
44561 char * kwnames[] = {
44562 (char *) "self",(char *) "n", NULL
44563 };
44564
44565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44567 if (!SWIG_IsOK(res1)) {
44568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44569 }
44570 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44571 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44572 if (!SWIG_IsOK(ecode2)) {
44573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44574 }
44575 arg2 = static_cast< unsigned int >(val2);
44576 {
44577 PyThreadState* __tstate = wxPyBeginAllowThreads();
44578 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44579 wxPyEndAllowThreads(__tstate);
44580 if (PyErr_Occurred()) SWIG_fail;
44581 }
44582 {
44583 #if wxUSE_UNICODE
44584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44585 #else
44586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44587 #endif
44588 }
44589 return resultobj;
44590 fail:
44591 return NULL;
44592 }
44593
44594
44595 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44596 PyObject *resultobj = 0;
44597 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44598 wxArrayString result;
44599 void *argp1 = 0 ;
44600 int res1 = 0 ;
44601 PyObject *swig_obj[1] ;
44602
44603 if (!args) SWIG_fail;
44604 swig_obj[0] = args;
44605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44606 if (!SWIG_IsOK(res1)) {
44607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44608 }
44609 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44610 {
44611 PyThreadState* __tstate = wxPyBeginAllowThreads();
44612 result = ((wxItemContainer const *)arg1)->GetStrings();
44613 wxPyEndAllowThreads(__tstate);
44614 if (PyErr_Occurred()) SWIG_fail;
44615 }
44616 {
44617 resultobj = wxArrayString2PyList_helper(result);
44618 }
44619 return resultobj;
44620 fail:
44621 return NULL;
44622 }
44623
44624
44625 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44626 PyObject *resultobj = 0;
44627 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44628 unsigned int arg2 ;
44629 wxString *arg3 = 0 ;
44630 void *argp1 = 0 ;
44631 int res1 = 0 ;
44632 unsigned int val2 ;
44633 int ecode2 = 0 ;
44634 bool temp3 = false ;
44635 PyObject * obj0 = 0 ;
44636 PyObject * obj1 = 0 ;
44637 PyObject * obj2 = 0 ;
44638 char * kwnames[] = {
44639 (char *) "self",(char *) "n",(char *) "s", NULL
44640 };
44641
44642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44644 if (!SWIG_IsOK(res1)) {
44645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44646 }
44647 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44648 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44649 if (!SWIG_IsOK(ecode2)) {
44650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44651 }
44652 arg2 = static_cast< unsigned int >(val2);
44653 {
44654 arg3 = wxString_in_helper(obj2);
44655 if (arg3 == NULL) SWIG_fail;
44656 temp3 = true;
44657 }
44658 {
44659 PyThreadState* __tstate = wxPyBeginAllowThreads();
44660 (arg1)->SetString(arg2,(wxString const &)*arg3);
44661 wxPyEndAllowThreads(__tstate);
44662 if (PyErr_Occurred()) SWIG_fail;
44663 }
44664 resultobj = SWIG_Py_Void();
44665 {
44666 if (temp3)
44667 delete arg3;
44668 }
44669 return resultobj;
44670 fail:
44671 {
44672 if (temp3)
44673 delete arg3;
44674 }
44675 return NULL;
44676 }
44677
44678
44679 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44680 PyObject *resultobj = 0;
44681 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44682 wxString *arg2 = 0 ;
44683 int result;
44684 void *argp1 = 0 ;
44685 int res1 = 0 ;
44686 bool temp2 = false ;
44687 PyObject * obj0 = 0 ;
44688 PyObject * obj1 = 0 ;
44689 char * kwnames[] = {
44690 (char *) "self",(char *) "s", NULL
44691 };
44692
44693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44695 if (!SWIG_IsOK(res1)) {
44696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44697 }
44698 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44699 {
44700 arg2 = wxString_in_helper(obj1);
44701 if (arg2 == NULL) SWIG_fail;
44702 temp2 = true;
44703 }
44704 {
44705 PyThreadState* __tstate = wxPyBeginAllowThreads();
44706 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44707 wxPyEndAllowThreads(__tstate);
44708 if (PyErr_Occurred()) SWIG_fail;
44709 }
44710 resultobj = SWIG_From_int(static_cast< int >(result));
44711 {
44712 if (temp2)
44713 delete arg2;
44714 }
44715 return resultobj;
44716 fail:
44717 {
44718 if (temp2)
44719 delete arg2;
44720 }
44721 return NULL;
44722 }
44723
44724
44725 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44726 PyObject *resultobj = 0;
44727 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44728 int arg2 ;
44729 void *argp1 = 0 ;
44730 int res1 = 0 ;
44731 int val2 ;
44732 int ecode2 = 0 ;
44733 PyObject * obj0 = 0 ;
44734 PyObject * obj1 = 0 ;
44735 char * kwnames[] = {
44736 (char *) "self",(char *) "n", NULL
44737 };
44738
44739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44741 if (!SWIG_IsOK(res1)) {
44742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44743 }
44744 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44745 ecode2 = SWIG_AsVal_int(obj1, &val2);
44746 if (!SWIG_IsOK(ecode2)) {
44747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44748 }
44749 arg2 = static_cast< int >(val2);
44750 {
44751 PyThreadState* __tstate = wxPyBeginAllowThreads();
44752 (arg1)->SetSelection(arg2);
44753 wxPyEndAllowThreads(__tstate);
44754 if (PyErr_Occurred()) SWIG_fail;
44755 }
44756 resultobj = SWIG_Py_Void();
44757 return resultobj;
44758 fail:
44759 return NULL;
44760 }
44761
44762
44763 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44764 PyObject *resultobj = 0;
44765 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44766 int result;
44767 void *argp1 = 0 ;
44768 int res1 = 0 ;
44769 PyObject *swig_obj[1] ;
44770
44771 if (!args) SWIG_fail;
44772 swig_obj[0] = args;
44773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44774 if (!SWIG_IsOK(res1)) {
44775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44776 }
44777 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44778 {
44779 PyThreadState* __tstate = wxPyBeginAllowThreads();
44780 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44781 wxPyEndAllowThreads(__tstate);
44782 if (PyErr_Occurred()) SWIG_fail;
44783 }
44784 resultobj = SWIG_From_int(static_cast< int >(result));
44785 return resultobj;
44786 fail:
44787 return NULL;
44788 }
44789
44790
44791 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44792 PyObject *resultobj = 0;
44793 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44794 wxString *arg2 = 0 ;
44795 bool result;
44796 void *argp1 = 0 ;
44797 int res1 = 0 ;
44798 bool temp2 = false ;
44799 PyObject * obj0 = 0 ;
44800 PyObject * obj1 = 0 ;
44801 char * kwnames[] = {
44802 (char *) "self",(char *) "s", NULL
44803 };
44804
44805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44807 if (!SWIG_IsOK(res1)) {
44808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44809 }
44810 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44811 {
44812 arg2 = wxString_in_helper(obj1);
44813 if (arg2 == NULL) SWIG_fail;
44814 temp2 = true;
44815 }
44816 {
44817 PyThreadState* __tstate = wxPyBeginAllowThreads();
44818 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44819 wxPyEndAllowThreads(__tstate);
44820 if (PyErr_Occurred()) SWIG_fail;
44821 }
44822 {
44823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44824 }
44825 {
44826 if (temp2)
44827 delete arg2;
44828 }
44829 return resultobj;
44830 fail:
44831 {
44832 if (temp2)
44833 delete arg2;
44834 }
44835 return NULL;
44836 }
44837
44838
44839 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44840 PyObject *resultobj = 0;
44841 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44842 wxString result;
44843 void *argp1 = 0 ;
44844 int res1 = 0 ;
44845 PyObject *swig_obj[1] ;
44846
44847 if (!args) SWIG_fail;
44848 swig_obj[0] = args;
44849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44850 if (!SWIG_IsOK(res1)) {
44851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44852 }
44853 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44854 {
44855 PyThreadState* __tstate = wxPyBeginAllowThreads();
44856 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44857 wxPyEndAllowThreads(__tstate);
44858 if (PyErr_Occurred()) SWIG_fail;
44859 }
44860 {
44861 #if wxUSE_UNICODE
44862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44863 #else
44864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44865 #endif
44866 }
44867 return resultobj;
44868 fail:
44869 return NULL;
44870 }
44871
44872
44873 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44874 PyObject *resultobj = 0;
44875 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44876 int arg2 ;
44877 void *argp1 = 0 ;
44878 int res1 = 0 ;
44879 int val2 ;
44880 int ecode2 = 0 ;
44881 PyObject * obj0 = 0 ;
44882 PyObject * obj1 = 0 ;
44883 char * kwnames[] = {
44884 (char *) "self",(char *) "n", NULL
44885 };
44886
44887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44889 if (!SWIG_IsOK(res1)) {
44890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44891 }
44892 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44893 ecode2 = SWIG_AsVal_int(obj1, &val2);
44894 if (!SWIG_IsOK(ecode2)) {
44895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44896 }
44897 arg2 = static_cast< int >(val2);
44898 {
44899 PyThreadState* __tstate = wxPyBeginAllowThreads();
44900 (arg1)->Select(arg2);
44901 wxPyEndAllowThreads(__tstate);
44902 if (PyErr_Occurred()) SWIG_fail;
44903 }
44904 resultobj = SWIG_Py_Void();
44905 return resultobj;
44906 fail:
44907 return NULL;
44908 }
44909
44910
44911 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44912 PyObject *obj;
44913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44914 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44915 return SWIG_Py_Void();
44916 }
44917
44918 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44919 PyObject *obj;
44920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44921 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44922 return SWIG_Py_Void();
44923 }
44924
44925 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44926 PyObject *resultobj = 0;
44927 wxSizerItem *result = 0 ;
44928
44929 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44930 {
44931 PyThreadState* __tstate = wxPyBeginAllowThreads();
44932 result = (wxSizerItem *)new wxSizerItem();
44933 wxPyEndAllowThreads(__tstate);
44934 if (PyErr_Occurred()) SWIG_fail;
44935 }
44936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44937 return resultobj;
44938 fail:
44939 return NULL;
44940 }
44941
44942
44943 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44944 PyObject *resultobj = 0;
44945 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44946 void *argp1 = 0 ;
44947 int res1 = 0 ;
44948 PyObject *swig_obj[1] ;
44949
44950 if (!args) SWIG_fail;
44951 swig_obj[0] = args;
44952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44953 if (!SWIG_IsOK(res1)) {
44954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44955 }
44956 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44957 {
44958 PyThreadState* __tstate = wxPyBeginAllowThreads();
44959 delete arg1;
44960
44961 wxPyEndAllowThreads(__tstate);
44962 if (PyErr_Occurred()) SWIG_fail;
44963 }
44964 resultobj = SWIG_Py_Void();
44965 return resultobj;
44966 fail:
44967 return NULL;
44968 }
44969
44970
44971 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44972 PyObject *resultobj = 0;
44973 wxWindow *arg1 = (wxWindow *) 0 ;
44974 int arg2 ;
44975 int arg3 ;
44976 int arg4 ;
44977 PyObject *arg5 = (PyObject *) NULL ;
44978 wxSizerItem *result = 0 ;
44979 void *argp1 = 0 ;
44980 int res1 = 0 ;
44981 int val2 ;
44982 int ecode2 = 0 ;
44983 int val3 ;
44984 int ecode3 = 0 ;
44985 int val4 ;
44986 int ecode4 = 0 ;
44987 PyObject * obj0 = 0 ;
44988 PyObject * obj1 = 0 ;
44989 PyObject * obj2 = 0 ;
44990 PyObject * obj3 = 0 ;
44991 PyObject * obj4 = 0 ;
44992 char * kwnames[] = {
44993 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44994 };
44995
44996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44998 if (!SWIG_IsOK(res1)) {
44999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45000 }
45001 arg1 = reinterpret_cast< wxWindow * >(argp1);
45002 ecode2 = SWIG_AsVal_int(obj1, &val2);
45003 if (!SWIG_IsOK(ecode2)) {
45004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45005 }
45006 arg2 = static_cast< int >(val2);
45007 ecode3 = SWIG_AsVal_int(obj2, &val3);
45008 if (!SWIG_IsOK(ecode3)) {
45009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45010 }
45011 arg3 = static_cast< int >(val3);
45012 ecode4 = SWIG_AsVal_int(obj3, &val4);
45013 if (!SWIG_IsOK(ecode4)) {
45014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45015 }
45016 arg4 = static_cast< int >(val4);
45017 if (obj4) {
45018 arg5 = obj4;
45019 }
45020 {
45021 PyThreadState* __tstate = wxPyBeginAllowThreads();
45022 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45023 wxPyEndAllowThreads(__tstate);
45024 if (PyErr_Occurred()) SWIG_fail;
45025 }
45026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45027 return resultobj;
45028 fail:
45029 return NULL;
45030 }
45031
45032
45033 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45034 PyObject *resultobj = 0;
45035 int arg1 ;
45036 int arg2 ;
45037 int arg3 ;
45038 int arg4 ;
45039 int arg5 ;
45040 PyObject *arg6 = (PyObject *) NULL ;
45041 wxSizerItem *result = 0 ;
45042 int val1 ;
45043 int ecode1 = 0 ;
45044 int val2 ;
45045 int ecode2 = 0 ;
45046 int val3 ;
45047 int ecode3 = 0 ;
45048 int val4 ;
45049 int ecode4 = 0 ;
45050 int val5 ;
45051 int ecode5 = 0 ;
45052 PyObject * obj0 = 0 ;
45053 PyObject * obj1 = 0 ;
45054 PyObject * obj2 = 0 ;
45055 PyObject * obj3 = 0 ;
45056 PyObject * obj4 = 0 ;
45057 PyObject * obj5 = 0 ;
45058 char * kwnames[] = {
45059 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45060 };
45061
45062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45063 ecode1 = SWIG_AsVal_int(obj0, &val1);
45064 if (!SWIG_IsOK(ecode1)) {
45065 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45066 }
45067 arg1 = static_cast< int >(val1);
45068 ecode2 = SWIG_AsVal_int(obj1, &val2);
45069 if (!SWIG_IsOK(ecode2)) {
45070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45071 }
45072 arg2 = static_cast< int >(val2);
45073 ecode3 = SWIG_AsVal_int(obj2, &val3);
45074 if (!SWIG_IsOK(ecode3)) {
45075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45076 }
45077 arg3 = static_cast< int >(val3);
45078 ecode4 = SWIG_AsVal_int(obj3, &val4);
45079 if (!SWIG_IsOK(ecode4)) {
45080 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45081 }
45082 arg4 = static_cast< int >(val4);
45083 ecode5 = SWIG_AsVal_int(obj4, &val5);
45084 if (!SWIG_IsOK(ecode5)) {
45085 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45086 }
45087 arg5 = static_cast< int >(val5);
45088 if (obj5) {
45089 arg6 = obj5;
45090 }
45091 {
45092 PyThreadState* __tstate = wxPyBeginAllowThreads();
45093 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45094 wxPyEndAllowThreads(__tstate);
45095 if (PyErr_Occurred()) SWIG_fail;
45096 }
45097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45098 return resultobj;
45099 fail:
45100 return NULL;
45101 }
45102
45103
45104 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45105 PyObject *resultobj = 0;
45106 wxSizer *arg1 = (wxSizer *) 0 ;
45107 int arg2 ;
45108 int arg3 ;
45109 int arg4 ;
45110 PyObject *arg5 = (PyObject *) NULL ;
45111 wxSizerItem *result = 0 ;
45112 int res1 = 0 ;
45113 int val2 ;
45114 int ecode2 = 0 ;
45115 int val3 ;
45116 int ecode3 = 0 ;
45117 int val4 ;
45118 int ecode4 = 0 ;
45119 PyObject * obj0 = 0 ;
45120 PyObject * obj1 = 0 ;
45121 PyObject * obj2 = 0 ;
45122 PyObject * obj3 = 0 ;
45123 PyObject * obj4 = 0 ;
45124 char * kwnames[] = {
45125 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45126 };
45127
45128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45129 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45130 if (!SWIG_IsOK(res1)) {
45131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45132 }
45133 ecode2 = SWIG_AsVal_int(obj1, &val2);
45134 if (!SWIG_IsOK(ecode2)) {
45135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45136 }
45137 arg2 = static_cast< int >(val2);
45138 ecode3 = SWIG_AsVal_int(obj2, &val3);
45139 if (!SWIG_IsOK(ecode3)) {
45140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45141 }
45142 arg3 = static_cast< int >(val3);
45143 ecode4 = SWIG_AsVal_int(obj3, &val4);
45144 if (!SWIG_IsOK(ecode4)) {
45145 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45146 }
45147 arg4 = static_cast< int >(val4);
45148 if (obj4) {
45149 arg5 = obj4;
45150 }
45151 {
45152 PyThreadState* __tstate = wxPyBeginAllowThreads();
45153 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45154 wxPyEndAllowThreads(__tstate);
45155 if (PyErr_Occurred()) SWIG_fail;
45156 }
45157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45158 return resultobj;
45159 fail:
45160 return NULL;
45161 }
45162
45163
45164 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45165 PyObject *resultobj = 0;
45166 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45167 void *argp1 = 0 ;
45168 int res1 = 0 ;
45169 PyObject *swig_obj[1] ;
45170
45171 if (!args) SWIG_fail;
45172 swig_obj[0] = args;
45173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45174 if (!SWIG_IsOK(res1)) {
45175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45176 }
45177 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45178 {
45179 PyThreadState* __tstate = wxPyBeginAllowThreads();
45180 (arg1)->DeleteWindows();
45181 wxPyEndAllowThreads(__tstate);
45182 if (PyErr_Occurred()) SWIG_fail;
45183 }
45184 resultobj = SWIG_Py_Void();
45185 return resultobj;
45186 fail:
45187 return NULL;
45188 }
45189
45190
45191 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45192 PyObject *resultobj = 0;
45193 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45194 void *argp1 = 0 ;
45195 int res1 = 0 ;
45196 PyObject *swig_obj[1] ;
45197
45198 if (!args) SWIG_fail;
45199 swig_obj[0] = args;
45200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45201 if (!SWIG_IsOK(res1)) {
45202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45203 }
45204 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45205 {
45206 PyThreadState* __tstate = wxPyBeginAllowThreads();
45207 (arg1)->DetachSizer();
45208 wxPyEndAllowThreads(__tstate);
45209 if (PyErr_Occurred()) SWIG_fail;
45210 }
45211 resultobj = SWIG_Py_Void();
45212 return resultobj;
45213 fail:
45214 return NULL;
45215 }
45216
45217
45218 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45219 PyObject *resultobj = 0;
45220 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45221 wxSize result;
45222 void *argp1 = 0 ;
45223 int res1 = 0 ;
45224 PyObject *swig_obj[1] ;
45225
45226 if (!args) SWIG_fail;
45227 swig_obj[0] = args;
45228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45229 if (!SWIG_IsOK(res1)) {
45230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45231 }
45232 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45233 {
45234 PyThreadState* __tstate = wxPyBeginAllowThreads();
45235 result = (arg1)->GetSize();
45236 wxPyEndAllowThreads(__tstate);
45237 if (PyErr_Occurred()) SWIG_fail;
45238 }
45239 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45240 return resultobj;
45241 fail:
45242 return NULL;
45243 }
45244
45245
45246 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45247 PyObject *resultobj = 0;
45248 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45249 wxSize result;
45250 void *argp1 = 0 ;
45251 int res1 = 0 ;
45252 PyObject *swig_obj[1] ;
45253
45254 if (!args) SWIG_fail;
45255 swig_obj[0] = args;
45256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45257 if (!SWIG_IsOK(res1)) {
45258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45259 }
45260 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45261 {
45262 PyThreadState* __tstate = wxPyBeginAllowThreads();
45263 result = (arg1)->CalcMin();
45264 wxPyEndAllowThreads(__tstate);
45265 if (PyErr_Occurred()) SWIG_fail;
45266 }
45267 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45268 return resultobj;
45269 fail:
45270 return NULL;
45271 }
45272
45273
45274 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45275 PyObject *resultobj = 0;
45276 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45277 wxPoint *arg2 = 0 ;
45278 wxSize *arg3 = 0 ;
45279 void *argp1 = 0 ;
45280 int res1 = 0 ;
45281 wxPoint temp2 ;
45282 wxSize temp3 ;
45283 PyObject * obj0 = 0 ;
45284 PyObject * obj1 = 0 ;
45285 PyObject * obj2 = 0 ;
45286 char * kwnames[] = {
45287 (char *) "self",(char *) "pos",(char *) "size", NULL
45288 };
45289
45290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45292 if (!SWIG_IsOK(res1)) {
45293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45294 }
45295 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45296 {
45297 arg2 = &temp2;
45298 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45299 }
45300 {
45301 arg3 = &temp3;
45302 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45303 }
45304 {
45305 PyThreadState* __tstate = wxPyBeginAllowThreads();
45306 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45307 wxPyEndAllowThreads(__tstate);
45308 if (PyErr_Occurred()) SWIG_fail;
45309 }
45310 resultobj = SWIG_Py_Void();
45311 return resultobj;
45312 fail:
45313 return NULL;
45314 }
45315
45316
45317 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45318 PyObject *resultobj = 0;
45319 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45320 wxSize result;
45321 void *argp1 = 0 ;
45322 int res1 = 0 ;
45323 PyObject *swig_obj[1] ;
45324
45325 if (!args) SWIG_fail;
45326 swig_obj[0] = args;
45327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45328 if (!SWIG_IsOK(res1)) {
45329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45330 }
45331 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45332 {
45333 PyThreadState* __tstate = wxPyBeginAllowThreads();
45334 result = (arg1)->GetMinSize();
45335 wxPyEndAllowThreads(__tstate);
45336 if (PyErr_Occurred()) SWIG_fail;
45337 }
45338 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45339 return resultobj;
45340 fail:
45341 return NULL;
45342 }
45343
45344
45345 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45346 PyObject *resultobj = 0;
45347 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45348 wxSize result;
45349 void *argp1 = 0 ;
45350 int res1 = 0 ;
45351 PyObject *swig_obj[1] ;
45352
45353 if (!args) SWIG_fail;
45354 swig_obj[0] = args;
45355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45356 if (!SWIG_IsOK(res1)) {
45357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45358 }
45359 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45360 {
45361 PyThreadState* __tstate = wxPyBeginAllowThreads();
45362 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45363 wxPyEndAllowThreads(__tstate);
45364 if (PyErr_Occurred()) SWIG_fail;
45365 }
45366 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45367 return resultobj;
45368 fail:
45369 return NULL;
45370 }
45371
45372
45373 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45374 PyObject *resultobj = 0;
45375 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45376 int arg2 ;
45377 int arg3 ;
45378 void *argp1 = 0 ;
45379 int res1 = 0 ;
45380 int val2 ;
45381 int ecode2 = 0 ;
45382 int val3 ;
45383 int ecode3 = 0 ;
45384 PyObject * obj0 = 0 ;
45385 PyObject * obj1 = 0 ;
45386 PyObject * obj2 = 0 ;
45387 char * kwnames[] = {
45388 (char *) "self",(char *) "x",(char *) "y", NULL
45389 };
45390
45391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45393 if (!SWIG_IsOK(res1)) {
45394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45395 }
45396 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45397 ecode2 = SWIG_AsVal_int(obj1, &val2);
45398 if (!SWIG_IsOK(ecode2)) {
45399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45400 }
45401 arg2 = static_cast< int >(val2);
45402 ecode3 = SWIG_AsVal_int(obj2, &val3);
45403 if (!SWIG_IsOK(ecode3)) {
45404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45405 }
45406 arg3 = static_cast< int >(val3);
45407 {
45408 PyThreadState* __tstate = wxPyBeginAllowThreads();
45409 (arg1)->SetInitSize(arg2,arg3);
45410 wxPyEndAllowThreads(__tstate);
45411 if (PyErr_Occurred()) SWIG_fail;
45412 }
45413 resultobj = SWIG_Py_Void();
45414 return resultobj;
45415 fail:
45416 return NULL;
45417 }
45418
45419
45420 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45421 PyObject *resultobj = 0;
45422 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45423 int arg2 ;
45424 int arg3 ;
45425 void *argp1 = 0 ;
45426 int res1 = 0 ;
45427 int val2 ;
45428 int ecode2 = 0 ;
45429 int val3 ;
45430 int ecode3 = 0 ;
45431 PyObject * obj0 = 0 ;
45432 PyObject * obj1 = 0 ;
45433 PyObject * obj2 = 0 ;
45434 char * kwnames[] = {
45435 (char *) "self",(char *) "width",(char *) "height", NULL
45436 };
45437
45438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45440 if (!SWIG_IsOK(res1)) {
45441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45442 }
45443 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45444 ecode2 = SWIG_AsVal_int(obj1, &val2);
45445 if (!SWIG_IsOK(ecode2)) {
45446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45447 }
45448 arg2 = static_cast< int >(val2);
45449 ecode3 = SWIG_AsVal_int(obj2, &val3);
45450 if (!SWIG_IsOK(ecode3)) {
45451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45452 }
45453 arg3 = static_cast< int >(val3);
45454 {
45455 PyThreadState* __tstate = wxPyBeginAllowThreads();
45456 (arg1)->SetRatio(arg2,arg3);
45457 wxPyEndAllowThreads(__tstate);
45458 if (PyErr_Occurred()) SWIG_fail;
45459 }
45460 resultobj = SWIG_Py_Void();
45461 return resultobj;
45462 fail:
45463 return NULL;
45464 }
45465
45466
45467 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45468 PyObject *resultobj = 0;
45469 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45470 wxSize *arg2 = 0 ;
45471 void *argp1 = 0 ;
45472 int res1 = 0 ;
45473 wxSize temp2 ;
45474 PyObject * obj0 = 0 ;
45475 PyObject * obj1 = 0 ;
45476 char * kwnames[] = {
45477 (char *) "self",(char *) "size", NULL
45478 };
45479
45480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45482 if (!SWIG_IsOK(res1)) {
45483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45484 }
45485 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45486 {
45487 arg2 = &temp2;
45488 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45489 }
45490 {
45491 PyThreadState* __tstate = wxPyBeginAllowThreads();
45492 (arg1)->SetRatio((wxSize const &)*arg2);
45493 wxPyEndAllowThreads(__tstate);
45494 if (PyErr_Occurred()) SWIG_fail;
45495 }
45496 resultobj = SWIG_Py_Void();
45497 return resultobj;
45498 fail:
45499 return NULL;
45500 }
45501
45502
45503 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45504 PyObject *resultobj = 0;
45505 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45506 float arg2 ;
45507 void *argp1 = 0 ;
45508 int res1 = 0 ;
45509 float val2 ;
45510 int ecode2 = 0 ;
45511 PyObject * obj0 = 0 ;
45512 PyObject * obj1 = 0 ;
45513 char * kwnames[] = {
45514 (char *) "self",(char *) "ratio", NULL
45515 };
45516
45517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45519 if (!SWIG_IsOK(res1)) {
45520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45521 }
45522 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45523 ecode2 = SWIG_AsVal_float(obj1, &val2);
45524 if (!SWIG_IsOK(ecode2)) {
45525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45526 }
45527 arg2 = static_cast< float >(val2);
45528 {
45529 PyThreadState* __tstate = wxPyBeginAllowThreads();
45530 (arg1)->SetRatio(arg2);
45531 wxPyEndAllowThreads(__tstate);
45532 if (PyErr_Occurred()) SWIG_fail;
45533 }
45534 resultobj = SWIG_Py_Void();
45535 return resultobj;
45536 fail:
45537 return NULL;
45538 }
45539
45540
45541 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45542 PyObject *resultobj = 0;
45543 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45544 float result;
45545 void *argp1 = 0 ;
45546 int res1 = 0 ;
45547 PyObject *swig_obj[1] ;
45548
45549 if (!args) SWIG_fail;
45550 swig_obj[0] = args;
45551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45552 if (!SWIG_IsOK(res1)) {
45553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45554 }
45555 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45556 {
45557 PyThreadState* __tstate = wxPyBeginAllowThreads();
45558 result = (float)(arg1)->GetRatio();
45559 wxPyEndAllowThreads(__tstate);
45560 if (PyErr_Occurred()) SWIG_fail;
45561 }
45562 resultobj = SWIG_From_float(static_cast< float >(result));
45563 return resultobj;
45564 fail:
45565 return NULL;
45566 }
45567
45568
45569 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45570 PyObject *resultobj = 0;
45571 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45572 wxRect result;
45573 void *argp1 = 0 ;
45574 int res1 = 0 ;
45575 PyObject *swig_obj[1] ;
45576
45577 if (!args) SWIG_fail;
45578 swig_obj[0] = args;
45579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45580 if (!SWIG_IsOK(res1)) {
45581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45582 }
45583 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45584 {
45585 PyThreadState* __tstate = wxPyBeginAllowThreads();
45586 result = (arg1)->GetRect();
45587 wxPyEndAllowThreads(__tstate);
45588 if (PyErr_Occurred()) SWIG_fail;
45589 }
45590 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45591 return resultobj;
45592 fail:
45593 return NULL;
45594 }
45595
45596
45597 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45598 PyObject *resultobj = 0;
45599 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45600 bool result;
45601 void *argp1 = 0 ;
45602 int res1 = 0 ;
45603 PyObject *swig_obj[1] ;
45604
45605 if (!args) SWIG_fail;
45606 swig_obj[0] = args;
45607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45608 if (!SWIG_IsOK(res1)) {
45609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45610 }
45611 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45612 {
45613 PyThreadState* __tstate = wxPyBeginAllowThreads();
45614 result = (bool)(arg1)->IsWindow();
45615 wxPyEndAllowThreads(__tstate);
45616 if (PyErr_Occurred()) SWIG_fail;
45617 }
45618 {
45619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45620 }
45621 return resultobj;
45622 fail:
45623 return NULL;
45624 }
45625
45626
45627 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45628 PyObject *resultobj = 0;
45629 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45630 bool result;
45631 void *argp1 = 0 ;
45632 int res1 = 0 ;
45633 PyObject *swig_obj[1] ;
45634
45635 if (!args) SWIG_fail;
45636 swig_obj[0] = args;
45637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45638 if (!SWIG_IsOK(res1)) {
45639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45640 }
45641 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45642 {
45643 PyThreadState* __tstate = wxPyBeginAllowThreads();
45644 result = (bool)(arg1)->IsSizer();
45645 wxPyEndAllowThreads(__tstate);
45646 if (PyErr_Occurred()) SWIG_fail;
45647 }
45648 {
45649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45650 }
45651 return resultobj;
45652 fail:
45653 return NULL;
45654 }
45655
45656
45657 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45658 PyObject *resultobj = 0;
45659 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45660 bool result;
45661 void *argp1 = 0 ;
45662 int res1 = 0 ;
45663 PyObject *swig_obj[1] ;
45664
45665 if (!args) SWIG_fail;
45666 swig_obj[0] = args;
45667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45668 if (!SWIG_IsOK(res1)) {
45669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45670 }
45671 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45672 {
45673 PyThreadState* __tstate = wxPyBeginAllowThreads();
45674 result = (bool)(arg1)->IsSpacer();
45675 wxPyEndAllowThreads(__tstate);
45676 if (PyErr_Occurred()) SWIG_fail;
45677 }
45678 {
45679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45680 }
45681 return resultobj;
45682 fail:
45683 return NULL;
45684 }
45685
45686
45687 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45688 PyObject *resultobj = 0;
45689 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45690 int arg2 ;
45691 void *argp1 = 0 ;
45692 int res1 = 0 ;
45693 int val2 ;
45694 int ecode2 = 0 ;
45695 PyObject * obj0 = 0 ;
45696 PyObject * obj1 = 0 ;
45697 char * kwnames[] = {
45698 (char *) "self",(char *) "proportion", NULL
45699 };
45700
45701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45703 if (!SWIG_IsOK(res1)) {
45704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45705 }
45706 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45707 ecode2 = SWIG_AsVal_int(obj1, &val2);
45708 if (!SWIG_IsOK(ecode2)) {
45709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45710 }
45711 arg2 = static_cast< int >(val2);
45712 {
45713 PyThreadState* __tstate = wxPyBeginAllowThreads();
45714 (arg1)->SetProportion(arg2);
45715 wxPyEndAllowThreads(__tstate);
45716 if (PyErr_Occurred()) SWIG_fail;
45717 }
45718 resultobj = SWIG_Py_Void();
45719 return resultobj;
45720 fail:
45721 return NULL;
45722 }
45723
45724
45725 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45726 PyObject *resultobj = 0;
45727 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45728 int result;
45729 void *argp1 = 0 ;
45730 int res1 = 0 ;
45731 PyObject *swig_obj[1] ;
45732
45733 if (!args) SWIG_fail;
45734 swig_obj[0] = args;
45735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45736 if (!SWIG_IsOK(res1)) {
45737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45738 }
45739 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45740 {
45741 PyThreadState* __tstate = wxPyBeginAllowThreads();
45742 result = (int)(arg1)->GetProportion();
45743 wxPyEndAllowThreads(__tstate);
45744 if (PyErr_Occurred()) SWIG_fail;
45745 }
45746 resultobj = SWIG_From_int(static_cast< int >(result));
45747 return resultobj;
45748 fail:
45749 return NULL;
45750 }
45751
45752
45753 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45754 PyObject *resultobj = 0;
45755 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45756 int arg2 ;
45757 void *argp1 = 0 ;
45758 int res1 = 0 ;
45759 int val2 ;
45760 int ecode2 = 0 ;
45761 PyObject * obj0 = 0 ;
45762 PyObject * obj1 = 0 ;
45763 char * kwnames[] = {
45764 (char *) "self",(char *) "flag", NULL
45765 };
45766
45767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45769 if (!SWIG_IsOK(res1)) {
45770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45771 }
45772 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45773 ecode2 = SWIG_AsVal_int(obj1, &val2);
45774 if (!SWIG_IsOK(ecode2)) {
45775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45776 }
45777 arg2 = static_cast< int >(val2);
45778 {
45779 PyThreadState* __tstate = wxPyBeginAllowThreads();
45780 (arg1)->SetFlag(arg2);
45781 wxPyEndAllowThreads(__tstate);
45782 if (PyErr_Occurred()) SWIG_fail;
45783 }
45784 resultobj = SWIG_Py_Void();
45785 return resultobj;
45786 fail:
45787 return NULL;
45788 }
45789
45790
45791 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45792 PyObject *resultobj = 0;
45793 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45794 int result;
45795 void *argp1 = 0 ;
45796 int res1 = 0 ;
45797 PyObject *swig_obj[1] ;
45798
45799 if (!args) SWIG_fail;
45800 swig_obj[0] = args;
45801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45802 if (!SWIG_IsOK(res1)) {
45803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45804 }
45805 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45806 {
45807 PyThreadState* __tstate = wxPyBeginAllowThreads();
45808 result = (int)(arg1)->GetFlag();
45809 wxPyEndAllowThreads(__tstate);
45810 if (PyErr_Occurred()) SWIG_fail;
45811 }
45812 resultobj = SWIG_From_int(static_cast< int >(result));
45813 return resultobj;
45814 fail:
45815 return NULL;
45816 }
45817
45818
45819 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45820 PyObject *resultobj = 0;
45821 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45822 int arg2 ;
45823 void *argp1 = 0 ;
45824 int res1 = 0 ;
45825 int val2 ;
45826 int ecode2 = 0 ;
45827 PyObject * obj0 = 0 ;
45828 PyObject * obj1 = 0 ;
45829 char * kwnames[] = {
45830 (char *) "self",(char *) "border", NULL
45831 };
45832
45833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45835 if (!SWIG_IsOK(res1)) {
45836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45837 }
45838 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45839 ecode2 = SWIG_AsVal_int(obj1, &val2);
45840 if (!SWIG_IsOK(ecode2)) {
45841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45842 }
45843 arg2 = static_cast< int >(val2);
45844 {
45845 PyThreadState* __tstate = wxPyBeginAllowThreads();
45846 (arg1)->SetBorder(arg2);
45847 wxPyEndAllowThreads(__tstate);
45848 if (PyErr_Occurred()) SWIG_fail;
45849 }
45850 resultobj = SWIG_Py_Void();
45851 return resultobj;
45852 fail:
45853 return NULL;
45854 }
45855
45856
45857 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45858 PyObject *resultobj = 0;
45859 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45860 int result;
45861 void *argp1 = 0 ;
45862 int res1 = 0 ;
45863 PyObject *swig_obj[1] ;
45864
45865 if (!args) SWIG_fail;
45866 swig_obj[0] = args;
45867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45868 if (!SWIG_IsOK(res1)) {
45869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45870 }
45871 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45872 {
45873 PyThreadState* __tstate = wxPyBeginAllowThreads();
45874 result = (int)(arg1)->GetBorder();
45875 wxPyEndAllowThreads(__tstate);
45876 if (PyErr_Occurred()) SWIG_fail;
45877 }
45878 resultobj = SWIG_From_int(static_cast< int >(result));
45879 return resultobj;
45880 fail:
45881 return NULL;
45882 }
45883
45884
45885 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45886 PyObject *resultobj = 0;
45887 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45888 wxWindow *result = 0 ;
45889 void *argp1 = 0 ;
45890 int res1 = 0 ;
45891 PyObject *swig_obj[1] ;
45892
45893 if (!args) SWIG_fail;
45894 swig_obj[0] = args;
45895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45896 if (!SWIG_IsOK(res1)) {
45897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45898 }
45899 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45900 {
45901 PyThreadState* __tstate = wxPyBeginAllowThreads();
45902 result = (wxWindow *)(arg1)->GetWindow();
45903 wxPyEndAllowThreads(__tstate);
45904 if (PyErr_Occurred()) SWIG_fail;
45905 }
45906 {
45907 resultobj = wxPyMake_wxObject(result, 0);
45908 }
45909 return resultobj;
45910 fail:
45911 return NULL;
45912 }
45913
45914
45915 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45916 PyObject *resultobj = 0;
45917 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45918 wxWindow *arg2 = (wxWindow *) 0 ;
45919 void *argp1 = 0 ;
45920 int res1 = 0 ;
45921 void *argp2 = 0 ;
45922 int res2 = 0 ;
45923 PyObject * obj0 = 0 ;
45924 PyObject * obj1 = 0 ;
45925 char * kwnames[] = {
45926 (char *) "self",(char *) "window", NULL
45927 };
45928
45929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45931 if (!SWIG_IsOK(res1)) {
45932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45933 }
45934 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45935 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45936 if (!SWIG_IsOK(res2)) {
45937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45938 }
45939 arg2 = reinterpret_cast< wxWindow * >(argp2);
45940 {
45941 PyThreadState* __tstate = wxPyBeginAllowThreads();
45942 (arg1)->SetWindow(arg2);
45943 wxPyEndAllowThreads(__tstate);
45944 if (PyErr_Occurred()) SWIG_fail;
45945 }
45946 resultobj = SWIG_Py_Void();
45947 return resultobj;
45948 fail:
45949 return NULL;
45950 }
45951
45952
45953 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45954 PyObject *resultobj = 0;
45955 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45956 wxSizer *result = 0 ;
45957 void *argp1 = 0 ;
45958 int res1 = 0 ;
45959 PyObject *swig_obj[1] ;
45960
45961 if (!args) SWIG_fail;
45962 swig_obj[0] = args;
45963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45964 if (!SWIG_IsOK(res1)) {
45965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45966 }
45967 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45968 {
45969 PyThreadState* __tstate = wxPyBeginAllowThreads();
45970 result = (wxSizer *)(arg1)->GetSizer();
45971 wxPyEndAllowThreads(__tstate);
45972 if (PyErr_Occurred()) SWIG_fail;
45973 }
45974 {
45975 resultobj = wxPyMake_wxObject(result, (bool)0);
45976 }
45977 return resultobj;
45978 fail:
45979 return NULL;
45980 }
45981
45982
45983 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45984 PyObject *resultobj = 0;
45985 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45986 wxSizer *arg2 = (wxSizer *) 0 ;
45987 void *argp1 = 0 ;
45988 int res1 = 0 ;
45989 int res2 = 0 ;
45990 PyObject * obj0 = 0 ;
45991 PyObject * obj1 = 0 ;
45992 char * kwnames[] = {
45993 (char *) "self",(char *) "sizer", NULL
45994 };
45995
45996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45998 if (!SWIG_IsOK(res1)) {
45999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46000 }
46001 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46002 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46003 if (!SWIG_IsOK(res2)) {
46004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46005 }
46006 {
46007 PyThreadState* __tstate = wxPyBeginAllowThreads();
46008 (arg1)->SetSizer(arg2);
46009 wxPyEndAllowThreads(__tstate);
46010 if (PyErr_Occurred()) SWIG_fail;
46011 }
46012 resultobj = SWIG_Py_Void();
46013 return resultobj;
46014 fail:
46015 return NULL;
46016 }
46017
46018
46019 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46020 PyObject *resultobj = 0;
46021 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46022 wxSize *result = 0 ;
46023 void *argp1 = 0 ;
46024 int res1 = 0 ;
46025 PyObject *swig_obj[1] ;
46026
46027 if (!args) SWIG_fail;
46028 swig_obj[0] = args;
46029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46030 if (!SWIG_IsOK(res1)) {
46031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46032 }
46033 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46034 {
46035 PyThreadState* __tstate = wxPyBeginAllowThreads();
46036 {
46037 wxSize const &_result_ref = (arg1)->GetSpacer();
46038 result = (wxSize *) &_result_ref;
46039 }
46040 wxPyEndAllowThreads(__tstate);
46041 if (PyErr_Occurred()) SWIG_fail;
46042 }
46043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46044 return resultobj;
46045 fail:
46046 return NULL;
46047 }
46048
46049
46050 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46051 PyObject *resultobj = 0;
46052 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46053 wxSize *arg2 = 0 ;
46054 void *argp1 = 0 ;
46055 int res1 = 0 ;
46056 wxSize temp2 ;
46057 PyObject * obj0 = 0 ;
46058 PyObject * obj1 = 0 ;
46059 char * kwnames[] = {
46060 (char *) "self",(char *) "size", NULL
46061 };
46062
46063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46065 if (!SWIG_IsOK(res1)) {
46066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46067 }
46068 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46069 {
46070 arg2 = &temp2;
46071 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46072 }
46073 {
46074 PyThreadState* __tstate = wxPyBeginAllowThreads();
46075 (arg1)->SetSpacer((wxSize const &)*arg2);
46076 wxPyEndAllowThreads(__tstate);
46077 if (PyErr_Occurred()) SWIG_fail;
46078 }
46079 resultobj = SWIG_Py_Void();
46080 return resultobj;
46081 fail:
46082 return NULL;
46083 }
46084
46085
46086 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46087 PyObject *resultobj = 0;
46088 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46089 bool arg2 ;
46090 void *argp1 = 0 ;
46091 int res1 = 0 ;
46092 bool val2 ;
46093 int ecode2 = 0 ;
46094 PyObject * obj0 = 0 ;
46095 PyObject * obj1 = 0 ;
46096 char * kwnames[] = {
46097 (char *) "self",(char *) "show", NULL
46098 };
46099
46100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46102 if (!SWIG_IsOK(res1)) {
46103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46104 }
46105 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46106 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46107 if (!SWIG_IsOK(ecode2)) {
46108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46109 }
46110 arg2 = static_cast< bool >(val2);
46111 {
46112 PyThreadState* __tstate = wxPyBeginAllowThreads();
46113 (arg1)->Show(arg2);
46114 wxPyEndAllowThreads(__tstate);
46115 if (PyErr_Occurred()) SWIG_fail;
46116 }
46117 resultobj = SWIG_Py_Void();
46118 return resultobj;
46119 fail:
46120 return NULL;
46121 }
46122
46123
46124 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46125 PyObject *resultobj = 0;
46126 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46127 bool result;
46128 void *argp1 = 0 ;
46129 int res1 = 0 ;
46130 PyObject *swig_obj[1] ;
46131
46132 if (!args) SWIG_fail;
46133 swig_obj[0] = args;
46134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46135 if (!SWIG_IsOK(res1)) {
46136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46137 }
46138 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46139 {
46140 PyThreadState* __tstate = wxPyBeginAllowThreads();
46141 result = (bool)(arg1)->IsShown();
46142 wxPyEndAllowThreads(__tstate);
46143 if (PyErr_Occurred()) SWIG_fail;
46144 }
46145 {
46146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46147 }
46148 return resultobj;
46149 fail:
46150 return NULL;
46151 }
46152
46153
46154 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46155 PyObject *resultobj = 0;
46156 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46157 wxPoint result;
46158 void *argp1 = 0 ;
46159 int res1 = 0 ;
46160 PyObject *swig_obj[1] ;
46161
46162 if (!args) SWIG_fail;
46163 swig_obj[0] = args;
46164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46165 if (!SWIG_IsOK(res1)) {
46166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46167 }
46168 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46169 {
46170 PyThreadState* __tstate = wxPyBeginAllowThreads();
46171 result = (arg1)->GetPosition();
46172 wxPyEndAllowThreads(__tstate);
46173 if (PyErr_Occurred()) SWIG_fail;
46174 }
46175 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46176 return resultobj;
46177 fail:
46178 return NULL;
46179 }
46180
46181
46182 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46183 PyObject *resultobj = 0;
46184 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46185 PyObject *result = 0 ;
46186 void *argp1 = 0 ;
46187 int res1 = 0 ;
46188 PyObject *swig_obj[1] ;
46189
46190 if (!args) SWIG_fail;
46191 swig_obj[0] = args;
46192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46193 if (!SWIG_IsOK(res1)) {
46194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46195 }
46196 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46197 {
46198 PyThreadState* __tstate = wxPyBeginAllowThreads();
46199 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46200 wxPyEndAllowThreads(__tstate);
46201 if (PyErr_Occurred()) SWIG_fail;
46202 }
46203 resultobj = result;
46204 return resultobj;
46205 fail:
46206 return NULL;
46207 }
46208
46209
46210 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46211 PyObject *resultobj = 0;
46212 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46213 PyObject *arg2 = (PyObject *) 0 ;
46214 void *argp1 = 0 ;
46215 int res1 = 0 ;
46216 PyObject * obj0 = 0 ;
46217 PyObject * obj1 = 0 ;
46218 char * kwnames[] = {
46219 (char *) "self",(char *) "userData", NULL
46220 };
46221
46222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46224 if (!SWIG_IsOK(res1)) {
46225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46226 }
46227 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46228 arg2 = obj1;
46229 {
46230 PyThreadState* __tstate = wxPyBeginAllowThreads();
46231 wxSizerItem_SetUserData(arg1,arg2);
46232 wxPyEndAllowThreads(__tstate);
46233 if (PyErr_Occurred()) SWIG_fail;
46234 }
46235 resultobj = SWIG_Py_Void();
46236 return resultobj;
46237 fail:
46238 return NULL;
46239 }
46240
46241
46242 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46243 PyObject *obj;
46244 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46245 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46246 return SWIG_Py_Void();
46247 }
46248
46249 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46250 return SWIG_Python_InitShadowInstance(args);
46251 }
46252
46253 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46254 PyObject *resultobj = 0;
46255 wxSizer *arg1 = (wxSizer *) 0 ;
46256 void *argp1 = 0 ;
46257 int res1 = 0 ;
46258 PyObject *swig_obj[1] ;
46259
46260 if (!args) SWIG_fail;
46261 swig_obj[0] = args;
46262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46263 if (!SWIG_IsOK(res1)) {
46264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46265 }
46266 arg1 = reinterpret_cast< wxSizer * >(argp1);
46267 {
46268 PyThreadState* __tstate = wxPyBeginAllowThreads();
46269 delete arg1;
46270
46271 wxPyEndAllowThreads(__tstate);
46272 if (PyErr_Occurred()) SWIG_fail;
46273 }
46274 resultobj = SWIG_Py_Void();
46275 return resultobj;
46276 fail:
46277 return NULL;
46278 }
46279
46280
46281 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46282 PyObject *resultobj = 0;
46283 wxSizer *arg1 = (wxSizer *) 0 ;
46284 PyObject *arg2 = (PyObject *) 0 ;
46285 void *argp1 = 0 ;
46286 int res1 = 0 ;
46287 PyObject * obj0 = 0 ;
46288 PyObject * obj1 = 0 ;
46289 char * kwnames[] = {
46290 (char *) "self",(char *) "_self", NULL
46291 };
46292
46293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46295 if (!SWIG_IsOK(res1)) {
46296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46297 }
46298 arg1 = reinterpret_cast< wxSizer * >(argp1);
46299 arg2 = obj1;
46300 {
46301 PyThreadState* __tstate = wxPyBeginAllowThreads();
46302 wxSizer__setOORInfo(arg1,arg2);
46303 wxPyEndAllowThreads(__tstate);
46304 if (PyErr_Occurred()) SWIG_fail;
46305 }
46306 resultobj = SWIG_Py_Void();
46307 return resultobj;
46308 fail:
46309 return NULL;
46310 }
46311
46312
46313 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46314 PyObject *resultobj = 0;
46315 wxSizer *arg1 = (wxSizer *) 0 ;
46316 PyObject *arg2 = (PyObject *) 0 ;
46317 int arg3 = (int) 0 ;
46318 int arg4 = (int) 0 ;
46319 int arg5 = (int) 0 ;
46320 PyObject *arg6 = (PyObject *) NULL ;
46321 wxSizerItem *result = 0 ;
46322 void *argp1 = 0 ;
46323 int res1 = 0 ;
46324 int val3 ;
46325 int ecode3 = 0 ;
46326 int val4 ;
46327 int ecode4 = 0 ;
46328 int val5 ;
46329 int ecode5 = 0 ;
46330 PyObject * obj0 = 0 ;
46331 PyObject * obj1 = 0 ;
46332 PyObject * obj2 = 0 ;
46333 PyObject * obj3 = 0 ;
46334 PyObject * obj4 = 0 ;
46335 PyObject * obj5 = 0 ;
46336 char * kwnames[] = {
46337 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46338 };
46339
46340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46342 if (!SWIG_IsOK(res1)) {
46343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46344 }
46345 arg1 = reinterpret_cast< wxSizer * >(argp1);
46346 arg2 = obj1;
46347 if (obj2) {
46348 ecode3 = SWIG_AsVal_int(obj2, &val3);
46349 if (!SWIG_IsOK(ecode3)) {
46350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46351 }
46352 arg3 = static_cast< int >(val3);
46353 }
46354 if (obj3) {
46355 ecode4 = SWIG_AsVal_int(obj3, &val4);
46356 if (!SWIG_IsOK(ecode4)) {
46357 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46358 }
46359 arg4 = static_cast< int >(val4);
46360 }
46361 if (obj4) {
46362 ecode5 = SWIG_AsVal_int(obj4, &val5);
46363 if (!SWIG_IsOK(ecode5)) {
46364 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46365 }
46366 arg5 = static_cast< int >(val5);
46367 }
46368 if (obj5) {
46369 arg6 = obj5;
46370 }
46371 {
46372 PyThreadState* __tstate = wxPyBeginAllowThreads();
46373 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46374 wxPyEndAllowThreads(__tstate);
46375 if (PyErr_Occurred()) SWIG_fail;
46376 }
46377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46378 return resultobj;
46379 fail:
46380 return NULL;
46381 }
46382
46383
46384 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46385 PyObject *resultobj = 0;
46386 wxSizer *arg1 = (wxSizer *) 0 ;
46387 int arg2 ;
46388 PyObject *arg3 = (PyObject *) 0 ;
46389 int arg4 = (int) 0 ;
46390 int arg5 = (int) 0 ;
46391 int arg6 = (int) 0 ;
46392 PyObject *arg7 = (PyObject *) NULL ;
46393 wxSizerItem *result = 0 ;
46394 void *argp1 = 0 ;
46395 int res1 = 0 ;
46396 int val2 ;
46397 int ecode2 = 0 ;
46398 int val4 ;
46399 int ecode4 = 0 ;
46400 int val5 ;
46401 int ecode5 = 0 ;
46402 int val6 ;
46403 int ecode6 = 0 ;
46404 PyObject * obj0 = 0 ;
46405 PyObject * obj1 = 0 ;
46406 PyObject * obj2 = 0 ;
46407 PyObject * obj3 = 0 ;
46408 PyObject * obj4 = 0 ;
46409 PyObject * obj5 = 0 ;
46410 PyObject * obj6 = 0 ;
46411 char * kwnames[] = {
46412 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46413 };
46414
46415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46417 if (!SWIG_IsOK(res1)) {
46418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46419 }
46420 arg1 = reinterpret_cast< wxSizer * >(argp1);
46421 ecode2 = SWIG_AsVal_int(obj1, &val2);
46422 if (!SWIG_IsOK(ecode2)) {
46423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46424 }
46425 arg2 = static_cast< int >(val2);
46426 arg3 = obj2;
46427 if (obj3) {
46428 ecode4 = SWIG_AsVal_int(obj3, &val4);
46429 if (!SWIG_IsOK(ecode4)) {
46430 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46431 }
46432 arg4 = static_cast< int >(val4);
46433 }
46434 if (obj4) {
46435 ecode5 = SWIG_AsVal_int(obj4, &val5);
46436 if (!SWIG_IsOK(ecode5)) {
46437 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46438 }
46439 arg5 = static_cast< int >(val5);
46440 }
46441 if (obj5) {
46442 ecode6 = SWIG_AsVal_int(obj5, &val6);
46443 if (!SWIG_IsOK(ecode6)) {
46444 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46445 }
46446 arg6 = static_cast< int >(val6);
46447 }
46448 if (obj6) {
46449 arg7 = obj6;
46450 }
46451 {
46452 PyThreadState* __tstate = wxPyBeginAllowThreads();
46453 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46454 wxPyEndAllowThreads(__tstate);
46455 if (PyErr_Occurred()) SWIG_fail;
46456 }
46457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46458 return resultobj;
46459 fail:
46460 return NULL;
46461 }
46462
46463
46464 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46465 PyObject *resultobj = 0;
46466 wxSizer *arg1 = (wxSizer *) 0 ;
46467 PyObject *arg2 = (PyObject *) 0 ;
46468 int arg3 = (int) 0 ;
46469 int arg4 = (int) 0 ;
46470 int arg5 = (int) 0 ;
46471 PyObject *arg6 = (PyObject *) NULL ;
46472 wxSizerItem *result = 0 ;
46473 void *argp1 = 0 ;
46474 int res1 = 0 ;
46475 int val3 ;
46476 int ecode3 = 0 ;
46477 int val4 ;
46478 int ecode4 = 0 ;
46479 int val5 ;
46480 int ecode5 = 0 ;
46481 PyObject * obj0 = 0 ;
46482 PyObject * obj1 = 0 ;
46483 PyObject * obj2 = 0 ;
46484 PyObject * obj3 = 0 ;
46485 PyObject * obj4 = 0 ;
46486 PyObject * obj5 = 0 ;
46487 char * kwnames[] = {
46488 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46489 };
46490
46491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46493 if (!SWIG_IsOK(res1)) {
46494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46495 }
46496 arg1 = reinterpret_cast< wxSizer * >(argp1);
46497 arg2 = obj1;
46498 if (obj2) {
46499 ecode3 = SWIG_AsVal_int(obj2, &val3);
46500 if (!SWIG_IsOK(ecode3)) {
46501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46502 }
46503 arg3 = static_cast< int >(val3);
46504 }
46505 if (obj3) {
46506 ecode4 = SWIG_AsVal_int(obj3, &val4);
46507 if (!SWIG_IsOK(ecode4)) {
46508 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46509 }
46510 arg4 = static_cast< int >(val4);
46511 }
46512 if (obj4) {
46513 ecode5 = SWIG_AsVal_int(obj4, &val5);
46514 if (!SWIG_IsOK(ecode5)) {
46515 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46516 }
46517 arg5 = static_cast< int >(val5);
46518 }
46519 if (obj5) {
46520 arg6 = obj5;
46521 }
46522 {
46523 PyThreadState* __tstate = wxPyBeginAllowThreads();
46524 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46525 wxPyEndAllowThreads(__tstate);
46526 if (PyErr_Occurred()) SWIG_fail;
46527 }
46528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46529 return resultobj;
46530 fail:
46531 return NULL;
46532 }
46533
46534
46535 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46536 PyObject *resultobj = 0;
46537 wxSizer *arg1 = (wxSizer *) 0 ;
46538 PyObject *arg2 = (PyObject *) 0 ;
46539 bool result;
46540 void *argp1 = 0 ;
46541 int res1 = 0 ;
46542 PyObject * obj0 = 0 ;
46543 PyObject * obj1 = 0 ;
46544 char * kwnames[] = {
46545 (char *) "self",(char *) "item", NULL
46546 };
46547
46548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46550 if (!SWIG_IsOK(res1)) {
46551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46552 }
46553 arg1 = reinterpret_cast< wxSizer * >(argp1);
46554 arg2 = obj1;
46555 {
46556 PyThreadState* __tstate = wxPyBeginAllowThreads();
46557 result = (bool)wxSizer_Remove(arg1,arg2);
46558 wxPyEndAllowThreads(__tstate);
46559 if (PyErr_Occurred()) SWIG_fail;
46560 }
46561 {
46562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46563 }
46564 return resultobj;
46565 fail:
46566 return NULL;
46567 }
46568
46569
46570 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46571 PyObject *resultobj = 0;
46572 wxSizer *arg1 = (wxSizer *) 0 ;
46573 PyObject *arg2 = (PyObject *) 0 ;
46574 bool result;
46575 void *argp1 = 0 ;
46576 int res1 = 0 ;
46577 PyObject * obj0 = 0 ;
46578 PyObject * obj1 = 0 ;
46579 char * kwnames[] = {
46580 (char *) "self",(char *) "item", NULL
46581 };
46582
46583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46585 if (!SWIG_IsOK(res1)) {
46586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46587 }
46588 arg1 = reinterpret_cast< wxSizer * >(argp1);
46589 arg2 = obj1;
46590 {
46591 PyThreadState* __tstate = wxPyBeginAllowThreads();
46592 result = (bool)wxSizer_Detach(arg1,arg2);
46593 wxPyEndAllowThreads(__tstate);
46594 if (PyErr_Occurred()) SWIG_fail;
46595 }
46596 {
46597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46598 }
46599 return resultobj;
46600 fail:
46601 return NULL;
46602 }
46603
46604
46605 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46606 PyObject *resultobj = 0;
46607 wxSizer *arg1 = (wxSizer *) 0 ;
46608 PyObject *arg2 = (PyObject *) 0 ;
46609 wxSizerItem *result = 0 ;
46610 void *argp1 = 0 ;
46611 int res1 = 0 ;
46612 PyObject * obj0 = 0 ;
46613 PyObject * obj1 = 0 ;
46614 char * kwnames[] = {
46615 (char *) "self",(char *) "item", NULL
46616 };
46617
46618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46620 if (!SWIG_IsOK(res1)) {
46621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46622 }
46623 arg1 = reinterpret_cast< wxSizer * >(argp1);
46624 arg2 = obj1;
46625 {
46626 PyThreadState* __tstate = wxPyBeginAllowThreads();
46627 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46628 wxPyEndAllowThreads(__tstate);
46629 if (PyErr_Occurred()) SWIG_fail;
46630 }
46631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46632 return resultobj;
46633 fail:
46634 return NULL;
46635 }
46636
46637
46638 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46639 PyObject *resultobj = 0;
46640 wxSizer *arg1 = (wxSizer *) 0 ;
46641 PyObject *arg2 = (PyObject *) 0 ;
46642 wxSize *arg3 = 0 ;
46643 void *argp1 = 0 ;
46644 int res1 = 0 ;
46645 wxSize temp3 ;
46646 PyObject * obj0 = 0 ;
46647 PyObject * obj1 = 0 ;
46648 PyObject * obj2 = 0 ;
46649 char * kwnames[] = {
46650 (char *) "self",(char *) "item",(char *) "size", NULL
46651 };
46652
46653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46655 if (!SWIG_IsOK(res1)) {
46656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46657 }
46658 arg1 = reinterpret_cast< wxSizer * >(argp1);
46659 arg2 = obj1;
46660 {
46661 arg3 = &temp3;
46662 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46663 }
46664 {
46665 PyThreadState* __tstate = wxPyBeginAllowThreads();
46666 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46667 wxPyEndAllowThreads(__tstate);
46668 if (PyErr_Occurred()) SWIG_fail;
46669 }
46670 resultobj = SWIG_Py_Void();
46671 return resultobj;
46672 fail:
46673 return NULL;
46674 }
46675
46676
46677 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46678 PyObject *resultobj = 0;
46679 wxSizer *arg1 = (wxSizer *) 0 ;
46680 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46681 wxSizerItem *result = 0 ;
46682 void *argp1 = 0 ;
46683 int res1 = 0 ;
46684 int res2 = 0 ;
46685 PyObject * obj0 = 0 ;
46686 PyObject * obj1 = 0 ;
46687 char * kwnames[] = {
46688 (char *) "self",(char *) "item", NULL
46689 };
46690
46691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46693 if (!SWIG_IsOK(res1)) {
46694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46695 }
46696 arg1 = reinterpret_cast< wxSizer * >(argp1);
46697 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46698 if (!SWIG_IsOK(res2)) {
46699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46700 }
46701 {
46702 PyThreadState* __tstate = wxPyBeginAllowThreads();
46703 result = (wxSizerItem *)(arg1)->Add(arg2);
46704 wxPyEndAllowThreads(__tstate);
46705 if (PyErr_Occurred()) SWIG_fail;
46706 }
46707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46708 return resultobj;
46709 fail:
46710 return NULL;
46711 }
46712
46713
46714 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46715 PyObject *resultobj = 0;
46716 wxSizer *arg1 = (wxSizer *) 0 ;
46717 size_t arg2 ;
46718 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46719 wxSizerItem *result = 0 ;
46720 void *argp1 = 0 ;
46721 int res1 = 0 ;
46722 size_t val2 ;
46723 int ecode2 = 0 ;
46724 int res3 = 0 ;
46725 PyObject * obj0 = 0 ;
46726 PyObject * obj1 = 0 ;
46727 PyObject * obj2 = 0 ;
46728 char * kwnames[] = {
46729 (char *) "self",(char *) "index",(char *) "item", NULL
46730 };
46731
46732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46734 if (!SWIG_IsOK(res1)) {
46735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46736 }
46737 arg1 = reinterpret_cast< wxSizer * >(argp1);
46738 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46739 if (!SWIG_IsOK(ecode2)) {
46740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46741 }
46742 arg2 = static_cast< size_t >(val2);
46743 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46744 if (!SWIG_IsOK(res3)) {
46745 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46746 }
46747 {
46748 PyThreadState* __tstate = wxPyBeginAllowThreads();
46749 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46750 wxPyEndAllowThreads(__tstate);
46751 if (PyErr_Occurred()) SWIG_fail;
46752 }
46753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46754 return resultobj;
46755 fail:
46756 return NULL;
46757 }
46758
46759
46760 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46761 PyObject *resultobj = 0;
46762 wxSizer *arg1 = (wxSizer *) 0 ;
46763 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46764 wxSizerItem *result = 0 ;
46765 void *argp1 = 0 ;
46766 int res1 = 0 ;
46767 int res2 = 0 ;
46768 PyObject * obj0 = 0 ;
46769 PyObject * obj1 = 0 ;
46770 char * kwnames[] = {
46771 (char *) "self",(char *) "item", NULL
46772 };
46773
46774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46776 if (!SWIG_IsOK(res1)) {
46777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46778 }
46779 arg1 = reinterpret_cast< wxSizer * >(argp1);
46780 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46781 if (!SWIG_IsOK(res2)) {
46782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46783 }
46784 {
46785 PyThreadState* __tstate = wxPyBeginAllowThreads();
46786 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46787 wxPyEndAllowThreads(__tstate);
46788 if (PyErr_Occurred()) SWIG_fail;
46789 }
46790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46791 return resultobj;
46792 fail:
46793 return NULL;
46794 }
46795
46796
46797 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46798 PyObject *resultobj = 0;
46799 wxSizer *arg1 = (wxSizer *) 0 ;
46800 int arg2 ;
46801 int arg3 ;
46802 int arg4 ;
46803 int arg5 ;
46804 void *argp1 = 0 ;
46805 int res1 = 0 ;
46806 int val2 ;
46807 int ecode2 = 0 ;
46808 int val3 ;
46809 int ecode3 = 0 ;
46810 int val4 ;
46811 int ecode4 = 0 ;
46812 int val5 ;
46813 int ecode5 = 0 ;
46814 PyObject * obj0 = 0 ;
46815 PyObject * obj1 = 0 ;
46816 PyObject * obj2 = 0 ;
46817 PyObject * obj3 = 0 ;
46818 PyObject * obj4 = 0 ;
46819 char * kwnames[] = {
46820 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46821 };
46822
46823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46825 if (!SWIG_IsOK(res1)) {
46826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46827 }
46828 arg1 = reinterpret_cast< wxSizer * >(argp1);
46829 ecode2 = SWIG_AsVal_int(obj1, &val2);
46830 if (!SWIG_IsOK(ecode2)) {
46831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46832 }
46833 arg2 = static_cast< int >(val2);
46834 ecode3 = SWIG_AsVal_int(obj2, &val3);
46835 if (!SWIG_IsOK(ecode3)) {
46836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46837 }
46838 arg3 = static_cast< int >(val3);
46839 ecode4 = SWIG_AsVal_int(obj3, &val4);
46840 if (!SWIG_IsOK(ecode4)) {
46841 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46842 }
46843 arg4 = static_cast< int >(val4);
46844 ecode5 = SWIG_AsVal_int(obj4, &val5);
46845 if (!SWIG_IsOK(ecode5)) {
46846 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46847 }
46848 arg5 = static_cast< int >(val5);
46849 {
46850 PyThreadState* __tstate = wxPyBeginAllowThreads();
46851 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46852 wxPyEndAllowThreads(__tstate);
46853 if (PyErr_Occurred()) SWIG_fail;
46854 }
46855 resultobj = SWIG_Py_Void();
46856 return resultobj;
46857 fail:
46858 return NULL;
46859 }
46860
46861
46862 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46863 PyObject *resultobj = 0;
46864 wxSizer *arg1 = (wxSizer *) 0 ;
46865 wxSize *arg2 = 0 ;
46866 void *argp1 = 0 ;
46867 int res1 = 0 ;
46868 wxSize temp2 ;
46869 PyObject * obj0 = 0 ;
46870 PyObject * obj1 = 0 ;
46871 char * kwnames[] = {
46872 (char *) "self",(char *) "size", NULL
46873 };
46874
46875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46877 if (!SWIG_IsOK(res1)) {
46878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46879 }
46880 arg1 = reinterpret_cast< wxSizer * >(argp1);
46881 {
46882 arg2 = &temp2;
46883 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46884 }
46885 {
46886 PyThreadState* __tstate = wxPyBeginAllowThreads();
46887 (arg1)->SetMinSize((wxSize const &)*arg2);
46888 wxPyEndAllowThreads(__tstate);
46889 if (PyErr_Occurred()) SWIG_fail;
46890 }
46891 resultobj = SWIG_Py_Void();
46892 return resultobj;
46893 fail:
46894 return NULL;
46895 }
46896
46897
46898 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46899 PyObject *resultobj = 0;
46900 wxSizer *arg1 = (wxSizer *) 0 ;
46901 wxSize result;
46902 void *argp1 = 0 ;
46903 int res1 = 0 ;
46904 PyObject *swig_obj[1] ;
46905
46906 if (!args) SWIG_fail;
46907 swig_obj[0] = args;
46908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46909 if (!SWIG_IsOK(res1)) {
46910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46911 }
46912 arg1 = reinterpret_cast< wxSizer * >(argp1);
46913 {
46914 PyThreadState* __tstate = wxPyBeginAllowThreads();
46915 result = (arg1)->GetSize();
46916 wxPyEndAllowThreads(__tstate);
46917 if (PyErr_Occurred()) SWIG_fail;
46918 }
46919 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46920 return resultobj;
46921 fail:
46922 return NULL;
46923 }
46924
46925
46926 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46927 PyObject *resultobj = 0;
46928 wxSizer *arg1 = (wxSizer *) 0 ;
46929 wxPoint result;
46930 void *argp1 = 0 ;
46931 int res1 = 0 ;
46932 PyObject *swig_obj[1] ;
46933
46934 if (!args) SWIG_fail;
46935 swig_obj[0] = args;
46936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46937 if (!SWIG_IsOK(res1)) {
46938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46939 }
46940 arg1 = reinterpret_cast< wxSizer * >(argp1);
46941 {
46942 PyThreadState* __tstate = wxPyBeginAllowThreads();
46943 result = (arg1)->GetPosition();
46944 wxPyEndAllowThreads(__tstate);
46945 if (PyErr_Occurred()) SWIG_fail;
46946 }
46947 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46948 return resultobj;
46949 fail:
46950 return NULL;
46951 }
46952
46953
46954 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46955 PyObject *resultobj = 0;
46956 wxSizer *arg1 = (wxSizer *) 0 ;
46957 wxSize result;
46958 void *argp1 = 0 ;
46959 int res1 = 0 ;
46960 PyObject *swig_obj[1] ;
46961
46962 if (!args) SWIG_fail;
46963 swig_obj[0] = args;
46964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46965 if (!SWIG_IsOK(res1)) {
46966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46967 }
46968 arg1 = reinterpret_cast< wxSizer * >(argp1);
46969 {
46970 PyThreadState* __tstate = wxPyBeginAllowThreads();
46971 result = (arg1)->GetMinSize();
46972 wxPyEndAllowThreads(__tstate);
46973 if (PyErr_Occurred()) SWIG_fail;
46974 }
46975 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46976 return resultobj;
46977 fail:
46978 return NULL;
46979 }
46980
46981
46982 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46983 PyObject *resultobj = 0;
46984 wxSizer *arg1 = (wxSizer *) 0 ;
46985 void *argp1 = 0 ;
46986 int res1 = 0 ;
46987 PyObject *swig_obj[1] ;
46988
46989 if (!args) SWIG_fail;
46990 swig_obj[0] = args;
46991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46992 if (!SWIG_IsOK(res1)) {
46993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46994 }
46995 arg1 = reinterpret_cast< wxSizer * >(argp1);
46996 {
46997 PyThreadState* __tstate = wxPyBeginAllowThreads();
46998 (arg1)->RecalcSizes();
46999 wxPyEndAllowThreads(__tstate);
47000 if (PyErr_Occurred()) SWIG_fail;
47001 }
47002 resultobj = SWIG_Py_Void();
47003 return resultobj;
47004 fail:
47005 return NULL;
47006 }
47007
47008
47009 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47010 PyObject *resultobj = 0;
47011 wxSizer *arg1 = (wxSizer *) 0 ;
47012 wxSize result;
47013 void *argp1 = 0 ;
47014 int res1 = 0 ;
47015 PyObject *swig_obj[1] ;
47016
47017 if (!args) SWIG_fail;
47018 swig_obj[0] = args;
47019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47020 if (!SWIG_IsOK(res1)) {
47021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47022 }
47023 arg1 = reinterpret_cast< wxSizer * >(argp1);
47024 {
47025 PyThreadState* __tstate = wxPyBeginAllowThreads();
47026 result = (arg1)->CalcMin();
47027 wxPyEndAllowThreads(__tstate);
47028 if (PyErr_Occurred()) SWIG_fail;
47029 }
47030 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47031 return resultobj;
47032 fail:
47033 return NULL;
47034 }
47035
47036
47037 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47038 PyObject *resultobj = 0;
47039 wxSizer *arg1 = (wxSizer *) 0 ;
47040 void *argp1 = 0 ;
47041 int res1 = 0 ;
47042 PyObject *swig_obj[1] ;
47043
47044 if (!args) SWIG_fail;
47045 swig_obj[0] = args;
47046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47047 if (!SWIG_IsOK(res1)) {
47048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47049 }
47050 arg1 = reinterpret_cast< wxSizer * >(argp1);
47051 {
47052 PyThreadState* __tstate = wxPyBeginAllowThreads();
47053 (arg1)->Layout();
47054 wxPyEndAllowThreads(__tstate);
47055 if (PyErr_Occurred()) SWIG_fail;
47056 }
47057 resultobj = SWIG_Py_Void();
47058 return resultobj;
47059 fail:
47060 return NULL;
47061 }
47062
47063
47064 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47065 PyObject *resultobj = 0;
47066 wxSizer *arg1 = (wxSizer *) 0 ;
47067 wxWindow *arg2 = (wxWindow *) 0 ;
47068 wxSize result;
47069 void *argp1 = 0 ;
47070 int res1 = 0 ;
47071 void *argp2 = 0 ;
47072 int res2 = 0 ;
47073 PyObject * obj0 = 0 ;
47074 PyObject * obj1 = 0 ;
47075 char * kwnames[] = {
47076 (char *) "self",(char *) "window", NULL
47077 };
47078
47079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47081 if (!SWIG_IsOK(res1)) {
47082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47083 }
47084 arg1 = reinterpret_cast< wxSizer * >(argp1);
47085 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47086 if (!SWIG_IsOK(res2)) {
47087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47088 }
47089 arg2 = reinterpret_cast< wxWindow * >(argp2);
47090 {
47091 PyThreadState* __tstate = wxPyBeginAllowThreads();
47092 result = (arg1)->Fit(arg2);
47093 wxPyEndAllowThreads(__tstate);
47094 if (PyErr_Occurred()) SWIG_fail;
47095 }
47096 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47097 return resultobj;
47098 fail:
47099 return NULL;
47100 }
47101
47102
47103 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47104 PyObject *resultobj = 0;
47105 wxSizer *arg1 = (wxSizer *) 0 ;
47106 wxWindow *arg2 = (wxWindow *) 0 ;
47107 void *argp1 = 0 ;
47108 int res1 = 0 ;
47109 void *argp2 = 0 ;
47110 int res2 = 0 ;
47111 PyObject * obj0 = 0 ;
47112 PyObject * obj1 = 0 ;
47113 char * kwnames[] = {
47114 (char *) "self",(char *) "window", NULL
47115 };
47116
47117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47119 if (!SWIG_IsOK(res1)) {
47120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47121 }
47122 arg1 = reinterpret_cast< wxSizer * >(argp1);
47123 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47124 if (!SWIG_IsOK(res2)) {
47125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47126 }
47127 arg2 = reinterpret_cast< wxWindow * >(argp2);
47128 {
47129 PyThreadState* __tstate = wxPyBeginAllowThreads();
47130 (arg1)->FitInside(arg2);
47131 wxPyEndAllowThreads(__tstate);
47132 if (PyErr_Occurred()) SWIG_fail;
47133 }
47134 resultobj = SWIG_Py_Void();
47135 return resultobj;
47136 fail:
47137 return NULL;
47138 }
47139
47140
47141 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47142 PyObject *resultobj = 0;
47143 wxSizer *arg1 = (wxSizer *) 0 ;
47144 wxWindow *arg2 = (wxWindow *) 0 ;
47145 void *argp1 = 0 ;
47146 int res1 = 0 ;
47147 void *argp2 = 0 ;
47148 int res2 = 0 ;
47149 PyObject * obj0 = 0 ;
47150 PyObject * obj1 = 0 ;
47151 char * kwnames[] = {
47152 (char *) "self",(char *) "window", NULL
47153 };
47154
47155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47157 if (!SWIG_IsOK(res1)) {
47158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47159 }
47160 arg1 = reinterpret_cast< wxSizer * >(argp1);
47161 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47162 if (!SWIG_IsOK(res2)) {
47163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47164 }
47165 arg2 = reinterpret_cast< wxWindow * >(argp2);
47166 {
47167 PyThreadState* __tstate = wxPyBeginAllowThreads();
47168 (arg1)->SetSizeHints(arg2);
47169 wxPyEndAllowThreads(__tstate);
47170 if (PyErr_Occurred()) SWIG_fail;
47171 }
47172 resultobj = SWIG_Py_Void();
47173 return resultobj;
47174 fail:
47175 return NULL;
47176 }
47177
47178
47179 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47180 PyObject *resultobj = 0;
47181 wxSizer *arg1 = (wxSizer *) 0 ;
47182 wxWindow *arg2 = (wxWindow *) 0 ;
47183 void *argp1 = 0 ;
47184 int res1 = 0 ;
47185 void *argp2 = 0 ;
47186 int res2 = 0 ;
47187 PyObject * obj0 = 0 ;
47188 PyObject * obj1 = 0 ;
47189 char * kwnames[] = {
47190 (char *) "self",(char *) "window", NULL
47191 };
47192
47193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47195 if (!SWIG_IsOK(res1)) {
47196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47197 }
47198 arg1 = reinterpret_cast< wxSizer * >(argp1);
47199 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47200 if (!SWIG_IsOK(res2)) {
47201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47202 }
47203 arg2 = reinterpret_cast< wxWindow * >(argp2);
47204 {
47205 PyThreadState* __tstate = wxPyBeginAllowThreads();
47206 (arg1)->SetVirtualSizeHints(arg2);
47207 wxPyEndAllowThreads(__tstate);
47208 if (PyErr_Occurred()) SWIG_fail;
47209 }
47210 resultobj = SWIG_Py_Void();
47211 return resultobj;
47212 fail:
47213 return NULL;
47214 }
47215
47216
47217 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47218 PyObject *resultobj = 0;
47219 wxSizer *arg1 = (wxSizer *) 0 ;
47220 bool arg2 = (bool) false ;
47221 void *argp1 = 0 ;
47222 int res1 = 0 ;
47223 bool val2 ;
47224 int ecode2 = 0 ;
47225 PyObject * obj0 = 0 ;
47226 PyObject * obj1 = 0 ;
47227 char * kwnames[] = {
47228 (char *) "self",(char *) "deleteWindows", NULL
47229 };
47230
47231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47233 if (!SWIG_IsOK(res1)) {
47234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47235 }
47236 arg1 = reinterpret_cast< wxSizer * >(argp1);
47237 if (obj1) {
47238 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47239 if (!SWIG_IsOK(ecode2)) {
47240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47241 }
47242 arg2 = static_cast< bool >(val2);
47243 }
47244 {
47245 PyThreadState* __tstate = wxPyBeginAllowThreads();
47246 (arg1)->Clear(arg2);
47247 wxPyEndAllowThreads(__tstate);
47248 if (PyErr_Occurred()) SWIG_fail;
47249 }
47250 resultobj = SWIG_Py_Void();
47251 return resultobj;
47252 fail:
47253 return NULL;
47254 }
47255
47256
47257 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47258 PyObject *resultobj = 0;
47259 wxSizer *arg1 = (wxSizer *) 0 ;
47260 void *argp1 = 0 ;
47261 int res1 = 0 ;
47262 PyObject *swig_obj[1] ;
47263
47264 if (!args) SWIG_fail;
47265 swig_obj[0] = args;
47266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47267 if (!SWIG_IsOK(res1)) {
47268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47269 }
47270 arg1 = reinterpret_cast< wxSizer * >(argp1);
47271 {
47272 PyThreadState* __tstate = wxPyBeginAllowThreads();
47273 (arg1)->DeleteWindows();
47274 wxPyEndAllowThreads(__tstate);
47275 if (PyErr_Occurred()) SWIG_fail;
47276 }
47277 resultobj = SWIG_Py_Void();
47278 return resultobj;
47279 fail:
47280 return NULL;
47281 }
47282
47283
47284 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47285 PyObject *resultobj = 0;
47286 wxSizer *arg1 = (wxSizer *) 0 ;
47287 PyObject *result = 0 ;
47288 void *argp1 = 0 ;
47289 int res1 = 0 ;
47290 PyObject *swig_obj[1] ;
47291
47292 if (!args) SWIG_fail;
47293 swig_obj[0] = args;
47294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47295 if (!SWIG_IsOK(res1)) {
47296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47297 }
47298 arg1 = reinterpret_cast< wxSizer * >(argp1);
47299 {
47300 PyThreadState* __tstate = wxPyBeginAllowThreads();
47301 result = (PyObject *)wxSizer_GetChildren(arg1);
47302 wxPyEndAllowThreads(__tstate);
47303 if (PyErr_Occurred()) SWIG_fail;
47304 }
47305 resultobj = result;
47306 return resultobj;
47307 fail:
47308 return NULL;
47309 }
47310
47311
47312 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47313 PyObject *resultobj = 0;
47314 wxSizer *arg1 = (wxSizer *) 0 ;
47315 PyObject *arg2 = (PyObject *) 0 ;
47316 bool arg3 = (bool) true ;
47317 bool arg4 = (bool) false ;
47318 bool result;
47319 void *argp1 = 0 ;
47320 int res1 = 0 ;
47321 bool val3 ;
47322 int ecode3 = 0 ;
47323 bool val4 ;
47324 int ecode4 = 0 ;
47325 PyObject * obj0 = 0 ;
47326 PyObject * obj1 = 0 ;
47327 PyObject * obj2 = 0 ;
47328 PyObject * obj3 = 0 ;
47329 char * kwnames[] = {
47330 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47331 };
47332
47333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47335 if (!SWIG_IsOK(res1)) {
47336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47337 }
47338 arg1 = reinterpret_cast< wxSizer * >(argp1);
47339 arg2 = obj1;
47340 if (obj2) {
47341 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47342 if (!SWIG_IsOK(ecode3)) {
47343 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47344 }
47345 arg3 = static_cast< bool >(val3);
47346 }
47347 if (obj3) {
47348 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47349 if (!SWIG_IsOK(ecode4)) {
47350 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47351 }
47352 arg4 = static_cast< bool >(val4);
47353 }
47354 {
47355 PyThreadState* __tstate = wxPyBeginAllowThreads();
47356 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47357 wxPyEndAllowThreads(__tstate);
47358 if (PyErr_Occurred()) SWIG_fail;
47359 }
47360 {
47361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47362 }
47363 return resultobj;
47364 fail:
47365 return NULL;
47366 }
47367
47368
47369 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47370 PyObject *resultobj = 0;
47371 wxSizer *arg1 = (wxSizer *) 0 ;
47372 PyObject *arg2 = (PyObject *) 0 ;
47373 bool result;
47374 void *argp1 = 0 ;
47375 int res1 = 0 ;
47376 PyObject * obj0 = 0 ;
47377 PyObject * obj1 = 0 ;
47378 char * kwnames[] = {
47379 (char *) "self",(char *) "item", NULL
47380 };
47381
47382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47384 if (!SWIG_IsOK(res1)) {
47385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47386 }
47387 arg1 = reinterpret_cast< wxSizer * >(argp1);
47388 arg2 = obj1;
47389 {
47390 PyThreadState* __tstate = wxPyBeginAllowThreads();
47391 result = (bool)wxSizer_IsShown(arg1,arg2);
47392 wxPyEndAllowThreads(__tstate);
47393 if (PyErr_Occurred()) SWIG_fail;
47394 }
47395 {
47396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47397 }
47398 return resultobj;
47399 fail:
47400 return NULL;
47401 }
47402
47403
47404 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47405 PyObject *resultobj = 0;
47406 wxSizer *arg1 = (wxSizer *) 0 ;
47407 bool arg2 ;
47408 void *argp1 = 0 ;
47409 int res1 = 0 ;
47410 bool val2 ;
47411 int ecode2 = 0 ;
47412 PyObject * obj0 = 0 ;
47413 PyObject * obj1 = 0 ;
47414 char * kwnames[] = {
47415 (char *) "self",(char *) "show", NULL
47416 };
47417
47418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47420 if (!SWIG_IsOK(res1)) {
47421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47422 }
47423 arg1 = reinterpret_cast< wxSizer * >(argp1);
47424 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47425 if (!SWIG_IsOK(ecode2)) {
47426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47427 }
47428 arg2 = static_cast< bool >(val2);
47429 {
47430 PyThreadState* __tstate = wxPyBeginAllowThreads();
47431 (arg1)->ShowItems(arg2);
47432 wxPyEndAllowThreads(__tstate);
47433 if (PyErr_Occurred()) SWIG_fail;
47434 }
47435 resultobj = SWIG_Py_Void();
47436 return resultobj;
47437 fail:
47438 return NULL;
47439 }
47440
47441
47442 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47443 PyObject *obj;
47444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47445 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47446 return SWIG_Py_Void();
47447 }
47448
47449 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47450 PyObject *resultobj = 0;
47451 wxPySizer *result = 0 ;
47452
47453 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47454 {
47455 PyThreadState* __tstate = wxPyBeginAllowThreads();
47456 result = (wxPySizer *)new wxPySizer();
47457 wxPyEndAllowThreads(__tstate);
47458 if (PyErr_Occurred()) SWIG_fail;
47459 }
47460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47461 return resultobj;
47462 fail:
47463 return NULL;
47464 }
47465
47466
47467 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47468 PyObject *resultobj = 0;
47469 wxPySizer *arg1 = (wxPySizer *) 0 ;
47470 PyObject *arg2 = (PyObject *) 0 ;
47471 PyObject *arg3 = (PyObject *) 0 ;
47472 void *argp1 = 0 ;
47473 int res1 = 0 ;
47474 PyObject * obj0 = 0 ;
47475 PyObject * obj1 = 0 ;
47476 PyObject * obj2 = 0 ;
47477 char * kwnames[] = {
47478 (char *) "self",(char *) "self",(char *) "_class", NULL
47479 };
47480
47481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47483 if (!SWIG_IsOK(res1)) {
47484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47485 }
47486 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47487 arg2 = obj1;
47488 arg3 = obj2;
47489 {
47490 PyThreadState* __tstate = wxPyBeginAllowThreads();
47491 (arg1)->_setCallbackInfo(arg2,arg3);
47492 wxPyEndAllowThreads(__tstate);
47493 if (PyErr_Occurred()) SWIG_fail;
47494 }
47495 resultobj = SWIG_Py_Void();
47496 return resultobj;
47497 fail:
47498 return NULL;
47499 }
47500
47501
47502 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47503 PyObject *obj;
47504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47505 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47506 return SWIG_Py_Void();
47507 }
47508
47509 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47510 return SWIG_Python_InitShadowInstance(args);
47511 }
47512
47513 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47514 PyObject *resultobj = 0;
47515 int arg1 = (int) wxHORIZONTAL ;
47516 wxBoxSizer *result = 0 ;
47517 int val1 ;
47518 int ecode1 = 0 ;
47519 PyObject * obj0 = 0 ;
47520 char * kwnames[] = {
47521 (char *) "orient", NULL
47522 };
47523
47524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47525 if (obj0) {
47526 ecode1 = SWIG_AsVal_int(obj0, &val1);
47527 if (!SWIG_IsOK(ecode1)) {
47528 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47529 }
47530 arg1 = static_cast< int >(val1);
47531 }
47532 {
47533 PyThreadState* __tstate = wxPyBeginAllowThreads();
47534 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47535 wxPyEndAllowThreads(__tstate);
47536 if (PyErr_Occurred()) SWIG_fail;
47537 }
47538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47539 return resultobj;
47540 fail:
47541 return NULL;
47542 }
47543
47544
47545 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47546 PyObject *resultobj = 0;
47547 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47548 int result;
47549 void *argp1 = 0 ;
47550 int res1 = 0 ;
47551 PyObject *swig_obj[1] ;
47552
47553 if (!args) SWIG_fail;
47554 swig_obj[0] = args;
47555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47556 if (!SWIG_IsOK(res1)) {
47557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47558 }
47559 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47560 {
47561 PyThreadState* __tstate = wxPyBeginAllowThreads();
47562 result = (int)(arg1)->GetOrientation();
47563 wxPyEndAllowThreads(__tstate);
47564 if (PyErr_Occurred()) SWIG_fail;
47565 }
47566 resultobj = SWIG_From_int(static_cast< int >(result));
47567 return resultobj;
47568 fail:
47569 return NULL;
47570 }
47571
47572
47573 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47574 PyObject *resultobj = 0;
47575 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47576 int arg2 ;
47577 void *argp1 = 0 ;
47578 int res1 = 0 ;
47579 int val2 ;
47580 int ecode2 = 0 ;
47581 PyObject * obj0 = 0 ;
47582 PyObject * obj1 = 0 ;
47583 char * kwnames[] = {
47584 (char *) "self",(char *) "orient", NULL
47585 };
47586
47587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47589 if (!SWIG_IsOK(res1)) {
47590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47591 }
47592 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47593 ecode2 = SWIG_AsVal_int(obj1, &val2);
47594 if (!SWIG_IsOK(ecode2)) {
47595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47596 }
47597 arg2 = static_cast< int >(val2);
47598 {
47599 PyThreadState* __tstate = wxPyBeginAllowThreads();
47600 (arg1)->SetOrientation(arg2);
47601 wxPyEndAllowThreads(__tstate);
47602 if (PyErr_Occurred()) SWIG_fail;
47603 }
47604 resultobj = SWIG_Py_Void();
47605 return resultobj;
47606 fail:
47607 return NULL;
47608 }
47609
47610
47611 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47612 PyObject *obj;
47613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47614 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47615 return SWIG_Py_Void();
47616 }
47617
47618 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47619 return SWIG_Python_InitShadowInstance(args);
47620 }
47621
47622 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47623 PyObject *resultobj = 0;
47624 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47625 int arg2 = (int) wxHORIZONTAL ;
47626 wxStaticBoxSizer *result = 0 ;
47627 void *argp1 = 0 ;
47628 int res1 = 0 ;
47629 int val2 ;
47630 int ecode2 = 0 ;
47631 PyObject * obj0 = 0 ;
47632 PyObject * obj1 = 0 ;
47633 char * kwnames[] = {
47634 (char *) "box",(char *) "orient", NULL
47635 };
47636
47637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47639 if (!SWIG_IsOK(res1)) {
47640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47641 }
47642 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47643 if (obj1) {
47644 ecode2 = SWIG_AsVal_int(obj1, &val2);
47645 if (!SWIG_IsOK(ecode2)) {
47646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47647 }
47648 arg2 = static_cast< int >(val2);
47649 }
47650 {
47651 PyThreadState* __tstate = wxPyBeginAllowThreads();
47652 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47653 wxPyEndAllowThreads(__tstate);
47654 if (PyErr_Occurred()) SWIG_fail;
47655 }
47656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47657 return resultobj;
47658 fail:
47659 return NULL;
47660 }
47661
47662
47663 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47664 PyObject *resultobj = 0;
47665 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47666 wxStaticBox *result = 0 ;
47667 void *argp1 = 0 ;
47668 int res1 = 0 ;
47669 PyObject *swig_obj[1] ;
47670
47671 if (!args) SWIG_fail;
47672 swig_obj[0] = args;
47673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47674 if (!SWIG_IsOK(res1)) {
47675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47676 }
47677 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47678 {
47679 PyThreadState* __tstate = wxPyBeginAllowThreads();
47680 result = (wxStaticBox *)(arg1)->GetStaticBox();
47681 wxPyEndAllowThreads(__tstate);
47682 if (PyErr_Occurred()) SWIG_fail;
47683 }
47684 {
47685 resultobj = wxPyMake_wxObject(result, (bool)0);
47686 }
47687 return resultobj;
47688 fail:
47689 return NULL;
47690 }
47691
47692
47693 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47694 PyObject *obj;
47695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47696 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47697 return SWIG_Py_Void();
47698 }
47699
47700 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47701 return SWIG_Python_InitShadowInstance(args);
47702 }
47703
47704 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47705 PyObject *resultobj = 0;
47706 int arg1 = (int) 1 ;
47707 int arg2 = (int) 0 ;
47708 int arg3 = (int) 0 ;
47709 int arg4 = (int) 0 ;
47710 wxGridSizer *result = 0 ;
47711 int val1 ;
47712 int ecode1 = 0 ;
47713 int val2 ;
47714 int ecode2 = 0 ;
47715 int val3 ;
47716 int ecode3 = 0 ;
47717 int val4 ;
47718 int ecode4 = 0 ;
47719 PyObject * obj0 = 0 ;
47720 PyObject * obj1 = 0 ;
47721 PyObject * obj2 = 0 ;
47722 PyObject * obj3 = 0 ;
47723 char * kwnames[] = {
47724 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47725 };
47726
47727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47728 if (obj0) {
47729 ecode1 = SWIG_AsVal_int(obj0, &val1);
47730 if (!SWIG_IsOK(ecode1)) {
47731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47732 }
47733 arg1 = static_cast< int >(val1);
47734 }
47735 if (obj1) {
47736 ecode2 = SWIG_AsVal_int(obj1, &val2);
47737 if (!SWIG_IsOK(ecode2)) {
47738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47739 }
47740 arg2 = static_cast< int >(val2);
47741 }
47742 if (obj2) {
47743 ecode3 = SWIG_AsVal_int(obj2, &val3);
47744 if (!SWIG_IsOK(ecode3)) {
47745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47746 }
47747 arg3 = static_cast< int >(val3);
47748 }
47749 if (obj3) {
47750 ecode4 = SWIG_AsVal_int(obj3, &val4);
47751 if (!SWIG_IsOK(ecode4)) {
47752 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47753 }
47754 arg4 = static_cast< int >(val4);
47755 }
47756 {
47757 PyThreadState* __tstate = wxPyBeginAllowThreads();
47758 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47759 wxPyEndAllowThreads(__tstate);
47760 if (PyErr_Occurred()) SWIG_fail;
47761 }
47762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47763 return resultobj;
47764 fail:
47765 return NULL;
47766 }
47767
47768
47769 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47770 PyObject *resultobj = 0;
47771 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47772 int arg2 ;
47773 void *argp1 = 0 ;
47774 int res1 = 0 ;
47775 int val2 ;
47776 int ecode2 = 0 ;
47777 PyObject * obj0 = 0 ;
47778 PyObject * obj1 = 0 ;
47779 char * kwnames[] = {
47780 (char *) "self",(char *) "cols", NULL
47781 };
47782
47783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47785 if (!SWIG_IsOK(res1)) {
47786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47787 }
47788 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47789 ecode2 = SWIG_AsVal_int(obj1, &val2);
47790 if (!SWIG_IsOK(ecode2)) {
47791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47792 }
47793 arg2 = static_cast< int >(val2);
47794 {
47795 PyThreadState* __tstate = wxPyBeginAllowThreads();
47796 (arg1)->SetCols(arg2);
47797 wxPyEndAllowThreads(__tstate);
47798 if (PyErr_Occurred()) SWIG_fail;
47799 }
47800 resultobj = SWIG_Py_Void();
47801 return resultobj;
47802 fail:
47803 return NULL;
47804 }
47805
47806
47807 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47808 PyObject *resultobj = 0;
47809 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47810 int arg2 ;
47811 void *argp1 = 0 ;
47812 int res1 = 0 ;
47813 int val2 ;
47814 int ecode2 = 0 ;
47815 PyObject * obj0 = 0 ;
47816 PyObject * obj1 = 0 ;
47817 char * kwnames[] = {
47818 (char *) "self",(char *) "rows", NULL
47819 };
47820
47821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47823 if (!SWIG_IsOK(res1)) {
47824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47825 }
47826 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47827 ecode2 = SWIG_AsVal_int(obj1, &val2);
47828 if (!SWIG_IsOK(ecode2)) {
47829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47830 }
47831 arg2 = static_cast< int >(val2);
47832 {
47833 PyThreadState* __tstate = wxPyBeginAllowThreads();
47834 (arg1)->SetRows(arg2);
47835 wxPyEndAllowThreads(__tstate);
47836 if (PyErr_Occurred()) SWIG_fail;
47837 }
47838 resultobj = SWIG_Py_Void();
47839 return resultobj;
47840 fail:
47841 return NULL;
47842 }
47843
47844
47845 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47846 PyObject *resultobj = 0;
47847 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47848 int arg2 ;
47849 void *argp1 = 0 ;
47850 int res1 = 0 ;
47851 int val2 ;
47852 int ecode2 = 0 ;
47853 PyObject * obj0 = 0 ;
47854 PyObject * obj1 = 0 ;
47855 char * kwnames[] = {
47856 (char *) "self",(char *) "gap", NULL
47857 };
47858
47859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47861 if (!SWIG_IsOK(res1)) {
47862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47863 }
47864 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47865 ecode2 = SWIG_AsVal_int(obj1, &val2);
47866 if (!SWIG_IsOK(ecode2)) {
47867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47868 }
47869 arg2 = static_cast< int >(val2);
47870 {
47871 PyThreadState* __tstate = wxPyBeginAllowThreads();
47872 (arg1)->SetVGap(arg2);
47873 wxPyEndAllowThreads(__tstate);
47874 if (PyErr_Occurred()) SWIG_fail;
47875 }
47876 resultobj = SWIG_Py_Void();
47877 return resultobj;
47878 fail:
47879 return NULL;
47880 }
47881
47882
47883 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47884 PyObject *resultobj = 0;
47885 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47886 int arg2 ;
47887 void *argp1 = 0 ;
47888 int res1 = 0 ;
47889 int val2 ;
47890 int ecode2 = 0 ;
47891 PyObject * obj0 = 0 ;
47892 PyObject * obj1 = 0 ;
47893 char * kwnames[] = {
47894 (char *) "self",(char *) "gap", NULL
47895 };
47896
47897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47899 if (!SWIG_IsOK(res1)) {
47900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47901 }
47902 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47903 ecode2 = SWIG_AsVal_int(obj1, &val2);
47904 if (!SWIG_IsOK(ecode2)) {
47905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47906 }
47907 arg2 = static_cast< int >(val2);
47908 {
47909 PyThreadState* __tstate = wxPyBeginAllowThreads();
47910 (arg1)->SetHGap(arg2);
47911 wxPyEndAllowThreads(__tstate);
47912 if (PyErr_Occurred()) SWIG_fail;
47913 }
47914 resultobj = SWIG_Py_Void();
47915 return resultobj;
47916 fail:
47917 return NULL;
47918 }
47919
47920
47921 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47922 PyObject *resultobj = 0;
47923 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47924 int result;
47925 void *argp1 = 0 ;
47926 int res1 = 0 ;
47927 PyObject *swig_obj[1] ;
47928
47929 if (!args) SWIG_fail;
47930 swig_obj[0] = args;
47931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47932 if (!SWIG_IsOK(res1)) {
47933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47934 }
47935 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47936 {
47937 PyThreadState* __tstate = wxPyBeginAllowThreads();
47938 result = (int)(arg1)->GetCols();
47939 wxPyEndAllowThreads(__tstate);
47940 if (PyErr_Occurred()) SWIG_fail;
47941 }
47942 resultobj = SWIG_From_int(static_cast< int >(result));
47943 return resultobj;
47944 fail:
47945 return NULL;
47946 }
47947
47948
47949 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47950 PyObject *resultobj = 0;
47951 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47952 int result;
47953 void *argp1 = 0 ;
47954 int res1 = 0 ;
47955 PyObject *swig_obj[1] ;
47956
47957 if (!args) SWIG_fail;
47958 swig_obj[0] = args;
47959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47960 if (!SWIG_IsOK(res1)) {
47961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47962 }
47963 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47964 {
47965 PyThreadState* __tstate = wxPyBeginAllowThreads();
47966 result = (int)(arg1)->GetRows();
47967 wxPyEndAllowThreads(__tstate);
47968 if (PyErr_Occurred()) SWIG_fail;
47969 }
47970 resultobj = SWIG_From_int(static_cast< int >(result));
47971 return resultobj;
47972 fail:
47973 return NULL;
47974 }
47975
47976
47977 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47978 PyObject *resultobj = 0;
47979 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47980 int result;
47981 void *argp1 = 0 ;
47982 int res1 = 0 ;
47983 PyObject *swig_obj[1] ;
47984
47985 if (!args) SWIG_fail;
47986 swig_obj[0] = args;
47987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47988 if (!SWIG_IsOK(res1)) {
47989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47990 }
47991 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47992 {
47993 PyThreadState* __tstate = wxPyBeginAllowThreads();
47994 result = (int)(arg1)->GetVGap();
47995 wxPyEndAllowThreads(__tstate);
47996 if (PyErr_Occurred()) SWIG_fail;
47997 }
47998 resultobj = SWIG_From_int(static_cast< int >(result));
47999 return resultobj;
48000 fail:
48001 return NULL;
48002 }
48003
48004
48005 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48006 PyObject *resultobj = 0;
48007 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48008 int result;
48009 void *argp1 = 0 ;
48010 int res1 = 0 ;
48011 PyObject *swig_obj[1] ;
48012
48013 if (!args) SWIG_fail;
48014 swig_obj[0] = args;
48015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48016 if (!SWIG_IsOK(res1)) {
48017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48018 }
48019 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48020 {
48021 PyThreadState* __tstate = wxPyBeginAllowThreads();
48022 result = (int)(arg1)->GetHGap();
48023 wxPyEndAllowThreads(__tstate);
48024 if (PyErr_Occurred()) SWIG_fail;
48025 }
48026 resultobj = SWIG_From_int(static_cast< int >(result));
48027 return resultobj;
48028 fail:
48029 return NULL;
48030 }
48031
48032
48033 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48034 PyObject *obj;
48035 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48036 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48037 return SWIG_Py_Void();
48038 }
48039
48040 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48041 return SWIG_Python_InitShadowInstance(args);
48042 }
48043
48044 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48045 PyObject *resultobj = 0;
48046 int arg1 = (int) 1 ;
48047 int arg2 = (int) 0 ;
48048 int arg3 = (int) 0 ;
48049 int arg4 = (int) 0 ;
48050 wxFlexGridSizer *result = 0 ;
48051 int val1 ;
48052 int ecode1 = 0 ;
48053 int val2 ;
48054 int ecode2 = 0 ;
48055 int val3 ;
48056 int ecode3 = 0 ;
48057 int val4 ;
48058 int ecode4 = 0 ;
48059 PyObject * obj0 = 0 ;
48060 PyObject * obj1 = 0 ;
48061 PyObject * obj2 = 0 ;
48062 PyObject * obj3 = 0 ;
48063 char * kwnames[] = {
48064 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48065 };
48066
48067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48068 if (obj0) {
48069 ecode1 = SWIG_AsVal_int(obj0, &val1);
48070 if (!SWIG_IsOK(ecode1)) {
48071 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48072 }
48073 arg1 = static_cast< int >(val1);
48074 }
48075 if (obj1) {
48076 ecode2 = SWIG_AsVal_int(obj1, &val2);
48077 if (!SWIG_IsOK(ecode2)) {
48078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48079 }
48080 arg2 = static_cast< int >(val2);
48081 }
48082 if (obj2) {
48083 ecode3 = SWIG_AsVal_int(obj2, &val3);
48084 if (!SWIG_IsOK(ecode3)) {
48085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48086 }
48087 arg3 = static_cast< int >(val3);
48088 }
48089 if (obj3) {
48090 ecode4 = SWIG_AsVal_int(obj3, &val4);
48091 if (!SWIG_IsOK(ecode4)) {
48092 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48093 }
48094 arg4 = static_cast< int >(val4);
48095 }
48096 {
48097 PyThreadState* __tstate = wxPyBeginAllowThreads();
48098 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48099 wxPyEndAllowThreads(__tstate);
48100 if (PyErr_Occurred()) SWIG_fail;
48101 }
48102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48103 return resultobj;
48104 fail:
48105 return NULL;
48106 }
48107
48108
48109 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48110 PyObject *resultobj = 0;
48111 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48112 size_t arg2 ;
48113 int arg3 = (int) 0 ;
48114 void *argp1 = 0 ;
48115 int res1 = 0 ;
48116 size_t val2 ;
48117 int ecode2 = 0 ;
48118 int val3 ;
48119 int ecode3 = 0 ;
48120 PyObject * obj0 = 0 ;
48121 PyObject * obj1 = 0 ;
48122 PyObject * obj2 = 0 ;
48123 char * kwnames[] = {
48124 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48125 };
48126
48127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48129 if (!SWIG_IsOK(res1)) {
48130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48131 }
48132 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48133 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48134 if (!SWIG_IsOK(ecode2)) {
48135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48136 }
48137 arg2 = static_cast< size_t >(val2);
48138 if (obj2) {
48139 ecode3 = SWIG_AsVal_int(obj2, &val3);
48140 if (!SWIG_IsOK(ecode3)) {
48141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48142 }
48143 arg3 = static_cast< int >(val3);
48144 }
48145 {
48146 PyThreadState* __tstate = wxPyBeginAllowThreads();
48147 (arg1)->AddGrowableRow(arg2,arg3);
48148 wxPyEndAllowThreads(__tstate);
48149 if (PyErr_Occurred()) SWIG_fail;
48150 }
48151 resultobj = SWIG_Py_Void();
48152 return resultobj;
48153 fail:
48154 return NULL;
48155 }
48156
48157
48158 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48159 PyObject *resultobj = 0;
48160 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48161 size_t arg2 ;
48162 void *argp1 = 0 ;
48163 int res1 = 0 ;
48164 size_t val2 ;
48165 int ecode2 = 0 ;
48166 PyObject * obj0 = 0 ;
48167 PyObject * obj1 = 0 ;
48168 char * kwnames[] = {
48169 (char *) "self",(char *) "idx", NULL
48170 };
48171
48172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48174 if (!SWIG_IsOK(res1)) {
48175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48176 }
48177 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48178 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48179 if (!SWIG_IsOK(ecode2)) {
48180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48181 }
48182 arg2 = static_cast< size_t >(val2);
48183 {
48184 PyThreadState* __tstate = wxPyBeginAllowThreads();
48185 (arg1)->RemoveGrowableRow(arg2);
48186 wxPyEndAllowThreads(__tstate);
48187 if (PyErr_Occurred()) SWIG_fail;
48188 }
48189 resultobj = SWIG_Py_Void();
48190 return resultobj;
48191 fail:
48192 return NULL;
48193 }
48194
48195
48196 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48197 PyObject *resultobj = 0;
48198 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48199 size_t arg2 ;
48200 int arg3 = (int) 0 ;
48201 void *argp1 = 0 ;
48202 int res1 = 0 ;
48203 size_t val2 ;
48204 int ecode2 = 0 ;
48205 int val3 ;
48206 int ecode3 = 0 ;
48207 PyObject * obj0 = 0 ;
48208 PyObject * obj1 = 0 ;
48209 PyObject * obj2 = 0 ;
48210 char * kwnames[] = {
48211 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48212 };
48213
48214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48216 if (!SWIG_IsOK(res1)) {
48217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48218 }
48219 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48220 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48221 if (!SWIG_IsOK(ecode2)) {
48222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48223 }
48224 arg2 = static_cast< size_t >(val2);
48225 if (obj2) {
48226 ecode3 = SWIG_AsVal_int(obj2, &val3);
48227 if (!SWIG_IsOK(ecode3)) {
48228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48229 }
48230 arg3 = static_cast< int >(val3);
48231 }
48232 {
48233 PyThreadState* __tstate = wxPyBeginAllowThreads();
48234 (arg1)->AddGrowableCol(arg2,arg3);
48235 wxPyEndAllowThreads(__tstate);
48236 if (PyErr_Occurred()) SWIG_fail;
48237 }
48238 resultobj = SWIG_Py_Void();
48239 return resultobj;
48240 fail:
48241 return NULL;
48242 }
48243
48244
48245 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48246 PyObject *resultobj = 0;
48247 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48248 size_t arg2 ;
48249 void *argp1 = 0 ;
48250 int res1 = 0 ;
48251 size_t val2 ;
48252 int ecode2 = 0 ;
48253 PyObject * obj0 = 0 ;
48254 PyObject * obj1 = 0 ;
48255 char * kwnames[] = {
48256 (char *) "self",(char *) "idx", NULL
48257 };
48258
48259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48261 if (!SWIG_IsOK(res1)) {
48262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48263 }
48264 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48265 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48266 if (!SWIG_IsOK(ecode2)) {
48267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48268 }
48269 arg2 = static_cast< size_t >(val2);
48270 {
48271 PyThreadState* __tstate = wxPyBeginAllowThreads();
48272 (arg1)->RemoveGrowableCol(arg2);
48273 wxPyEndAllowThreads(__tstate);
48274 if (PyErr_Occurred()) SWIG_fail;
48275 }
48276 resultobj = SWIG_Py_Void();
48277 return resultobj;
48278 fail:
48279 return NULL;
48280 }
48281
48282
48283 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48284 PyObject *resultobj = 0;
48285 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48286 int arg2 ;
48287 void *argp1 = 0 ;
48288 int res1 = 0 ;
48289 int val2 ;
48290 int ecode2 = 0 ;
48291 PyObject * obj0 = 0 ;
48292 PyObject * obj1 = 0 ;
48293 char * kwnames[] = {
48294 (char *) "self",(char *) "direction", NULL
48295 };
48296
48297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48299 if (!SWIG_IsOK(res1)) {
48300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48301 }
48302 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48303 ecode2 = SWIG_AsVal_int(obj1, &val2);
48304 if (!SWIG_IsOK(ecode2)) {
48305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48306 }
48307 arg2 = static_cast< int >(val2);
48308 {
48309 PyThreadState* __tstate = wxPyBeginAllowThreads();
48310 (arg1)->SetFlexibleDirection(arg2);
48311 wxPyEndAllowThreads(__tstate);
48312 if (PyErr_Occurred()) SWIG_fail;
48313 }
48314 resultobj = SWIG_Py_Void();
48315 return resultobj;
48316 fail:
48317 return NULL;
48318 }
48319
48320
48321 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48322 PyObject *resultobj = 0;
48323 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48324 int result;
48325 void *argp1 = 0 ;
48326 int res1 = 0 ;
48327 PyObject *swig_obj[1] ;
48328
48329 if (!args) SWIG_fail;
48330 swig_obj[0] = args;
48331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48332 if (!SWIG_IsOK(res1)) {
48333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48334 }
48335 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48336 {
48337 PyThreadState* __tstate = wxPyBeginAllowThreads();
48338 result = (int)(arg1)->GetFlexibleDirection();
48339 wxPyEndAllowThreads(__tstate);
48340 if (PyErr_Occurred()) SWIG_fail;
48341 }
48342 resultobj = SWIG_From_int(static_cast< int >(result));
48343 return resultobj;
48344 fail:
48345 return NULL;
48346 }
48347
48348
48349 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48350 PyObject *resultobj = 0;
48351 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48352 wxFlexSizerGrowMode arg2 ;
48353 void *argp1 = 0 ;
48354 int res1 = 0 ;
48355 int val2 ;
48356 int ecode2 = 0 ;
48357 PyObject * obj0 = 0 ;
48358 PyObject * obj1 = 0 ;
48359 char * kwnames[] = {
48360 (char *) "self",(char *) "mode", NULL
48361 };
48362
48363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48365 if (!SWIG_IsOK(res1)) {
48366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48367 }
48368 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48369 ecode2 = SWIG_AsVal_int(obj1, &val2);
48370 if (!SWIG_IsOK(ecode2)) {
48371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48372 }
48373 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48374 {
48375 PyThreadState* __tstate = wxPyBeginAllowThreads();
48376 (arg1)->SetNonFlexibleGrowMode(arg2);
48377 wxPyEndAllowThreads(__tstate);
48378 if (PyErr_Occurred()) SWIG_fail;
48379 }
48380 resultobj = SWIG_Py_Void();
48381 return resultobj;
48382 fail:
48383 return NULL;
48384 }
48385
48386
48387 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48388 PyObject *resultobj = 0;
48389 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48390 wxFlexSizerGrowMode result;
48391 void *argp1 = 0 ;
48392 int res1 = 0 ;
48393 PyObject *swig_obj[1] ;
48394
48395 if (!args) SWIG_fail;
48396 swig_obj[0] = args;
48397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48398 if (!SWIG_IsOK(res1)) {
48399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48400 }
48401 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48402 {
48403 PyThreadState* __tstate = wxPyBeginAllowThreads();
48404 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48405 wxPyEndAllowThreads(__tstate);
48406 if (PyErr_Occurred()) SWIG_fail;
48407 }
48408 resultobj = SWIG_From_int(static_cast< int >(result));
48409 return resultobj;
48410 fail:
48411 return NULL;
48412 }
48413
48414
48415 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48416 PyObject *resultobj = 0;
48417 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48418 wxArrayInt *result = 0 ;
48419 void *argp1 = 0 ;
48420 int res1 = 0 ;
48421 PyObject *swig_obj[1] ;
48422
48423 if (!args) SWIG_fail;
48424 swig_obj[0] = args;
48425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48426 if (!SWIG_IsOK(res1)) {
48427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48428 }
48429 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48430 {
48431 PyThreadState* __tstate = wxPyBeginAllowThreads();
48432 {
48433 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48434 result = (wxArrayInt *) &_result_ref;
48435 }
48436 wxPyEndAllowThreads(__tstate);
48437 if (PyErr_Occurred()) SWIG_fail;
48438 }
48439 {
48440 resultobj = PyList_New(0);
48441 size_t idx;
48442 for (idx = 0; idx < result->GetCount(); idx += 1) {
48443 PyObject* val = PyInt_FromLong( result->Item(idx) );
48444 PyList_Append(resultobj, val);
48445 Py_DECREF(val);
48446 }
48447 }
48448 return resultobj;
48449 fail:
48450 return NULL;
48451 }
48452
48453
48454 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48455 PyObject *resultobj = 0;
48456 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48457 wxArrayInt *result = 0 ;
48458 void *argp1 = 0 ;
48459 int res1 = 0 ;
48460 PyObject *swig_obj[1] ;
48461
48462 if (!args) SWIG_fail;
48463 swig_obj[0] = args;
48464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48465 if (!SWIG_IsOK(res1)) {
48466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48467 }
48468 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48469 {
48470 PyThreadState* __tstate = wxPyBeginAllowThreads();
48471 {
48472 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48473 result = (wxArrayInt *) &_result_ref;
48474 }
48475 wxPyEndAllowThreads(__tstate);
48476 if (PyErr_Occurred()) SWIG_fail;
48477 }
48478 {
48479 resultobj = PyList_New(0);
48480 size_t idx;
48481 for (idx = 0; idx < result->GetCount(); idx += 1) {
48482 PyObject* val = PyInt_FromLong( result->Item(idx) );
48483 PyList_Append(resultobj, val);
48484 Py_DECREF(val);
48485 }
48486 }
48487 return resultobj;
48488 fail:
48489 return NULL;
48490 }
48491
48492
48493 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48494 PyObject *obj;
48495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48496 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48497 return SWIG_Py_Void();
48498 }
48499
48500 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48501 return SWIG_Python_InitShadowInstance(args);
48502 }
48503
48504 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48505 PyObject *resultobj = 0;
48506 wxStdDialogButtonSizer *result = 0 ;
48507
48508 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48509 {
48510 PyThreadState* __tstate = wxPyBeginAllowThreads();
48511 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48512 wxPyEndAllowThreads(__tstate);
48513 if (PyErr_Occurred()) SWIG_fail;
48514 }
48515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48516 return resultobj;
48517 fail:
48518 return NULL;
48519 }
48520
48521
48522 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48523 PyObject *resultobj = 0;
48524 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48525 wxButton *arg2 = (wxButton *) 0 ;
48526 void *argp1 = 0 ;
48527 int res1 = 0 ;
48528 void *argp2 = 0 ;
48529 int res2 = 0 ;
48530 PyObject * obj0 = 0 ;
48531 PyObject * obj1 = 0 ;
48532 char * kwnames[] = {
48533 (char *) "self",(char *) "button", NULL
48534 };
48535
48536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48538 if (!SWIG_IsOK(res1)) {
48539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48540 }
48541 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48542 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48543 if (!SWIG_IsOK(res2)) {
48544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48545 }
48546 arg2 = reinterpret_cast< wxButton * >(argp2);
48547 {
48548 PyThreadState* __tstate = wxPyBeginAllowThreads();
48549 (arg1)->AddButton(arg2);
48550 wxPyEndAllowThreads(__tstate);
48551 if (PyErr_Occurred()) SWIG_fail;
48552 }
48553 resultobj = SWIG_Py_Void();
48554 return resultobj;
48555 fail:
48556 return NULL;
48557 }
48558
48559
48560 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48561 PyObject *resultobj = 0;
48562 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48563 void *argp1 = 0 ;
48564 int res1 = 0 ;
48565 PyObject *swig_obj[1] ;
48566
48567 if (!args) SWIG_fail;
48568 swig_obj[0] = args;
48569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48570 if (!SWIG_IsOK(res1)) {
48571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48572 }
48573 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48574 {
48575 PyThreadState* __tstate = wxPyBeginAllowThreads();
48576 (arg1)->Realize();
48577 wxPyEndAllowThreads(__tstate);
48578 if (PyErr_Occurred()) SWIG_fail;
48579 }
48580 resultobj = SWIG_Py_Void();
48581 return resultobj;
48582 fail:
48583 return NULL;
48584 }
48585
48586
48587 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48588 PyObject *resultobj = 0;
48589 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48590 wxButton *arg2 = (wxButton *) 0 ;
48591 void *argp1 = 0 ;
48592 int res1 = 0 ;
48593 void *argp2 = 0 ;
48594 int res2 = 0 ;
48595 PyObject * obj0 = 0 ;
48596 PyObject * obj1 = 0 ;
48597 char * kwnames[] = {
48598 (char *) "self",(char *) "button", NULL
48599 };
48600
48601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48603 if (!SWIG_IsOK(res1)) {
48604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48605 }
48606 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48608 if (!SWIG_IsOK(res2)) {
48609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48610 }
48611 arg2 = reinterpret_cast< wxButton * >(argp2);
48612 {
48613 PyThreadState* __tstate = wxPyBeginAllowThreads();
48614 (arg1)->SetAffirmativeButton(arg2);
48615 wxPyEndAllowThreads(__tstate);
48616 if (PyErr_Occurred()) SWIG_fail;
48617 }
48618 resultobj = SWIG_Py_Void();
48619 return resultobj;
48620 fail:
48621 return NULL;
48622 }
48623
48624
48625 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48626 PyObject *resultobj = 0;
48627 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48628 wxButton *arg2 = (wxButton *) 0 ;
48629 void *argp1 = 0 ;
48630 int res1 = 0 ;
48631 void *argp2 = 0 ;
48632 int res2 = 0 ;
48633 PyObject * obj0 = 0 ;
48634 PyObject * obj1 = 0 ;
48635 char * kwnames[] = {
48636 (char *) "self",(char *) "button", NULL
48637 };
48638
48639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48641 if (!SWIG_IsOK(res1)) {
48642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48643 }
48644 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48645 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48646 if (!SWIG_IsOK(res2)) {
48647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48648 }
48649 arg2 = reinterpret_cast< wxButton * >(argp2);
48650 {
48651 PyThreadState* __tstate = wxPyBeginAllowThreads();
48652 (arg1)->SetNegativeButton(arg2);
48653 wxPyEndAllowThreads(__tstate);
48654 if (PyErr_Occurred()) SWIG_fail;
48655 }
48656 resultobj = SWIG_Py_Void();
48657 return resultobj;
48658 fail:
48659 return NULL;
48660 }
48661
48662
48663 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48664 PyObject *resultobj = 0;
48665 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48666 wxButton *arg2 = (wxButton *) 0 ;
48667 void *argp1 = 0 ;
48668 int res1 = 0 ;
48669 void *argp2 = 0 ;
48670 int res2 = 0 ;
48671 PyObject * obj0 = 0 ;
48672 PyObject * obj1 = 0 ;
48673 char * kwnames[] = {
48674 (char *) "self",(char *) "button", NULL
48675 };
48676
48677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48679 if (!SWIG_IsOK(res1)) {
48680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48681 }
48682 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48683 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48684 if (!SWIG_IsOK(res2)) {
48685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48686 }
48687 arg2 = reinterpret_cast< wxButton * >(argp2);
48688 {
48689 PyThreadState* __tstate = wxPyBeginAllowThreads();
48690 (arg1)->SetCancelButton(arg2);
48691 wxPyEndAllowThreads(__tstate);
48692 if (PyErr_Occurred()) SWIG_fail;
48693 }
48694 resultobj = SWIG_Py_Void();
48695 return resultobj;
48696 fail:
48697 return NULL;
48698 }
48699
48700
48701 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48702 PyObject *resultobj = 0;
48703 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48704 wxButton *result = 0 ;
48705 void *argp1 = 0 ;
48706 int res1 = 0 ;
48707 PyObject *swig_obj[1] ;
48708
48709 if (!args) SWIG_fail;
48710 swig_obj[0] = args;
48711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48712 if (!SWIG_IsOK(res1)) {
48713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48714 }
48715 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48716 {
48717 PyThreadState* __tstate = wxPyBeginAllowThreads();
48718 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48719 wxPyEndAllowThreads(__tstate);
48720 if (PyErr_Occurred()) SWIG_fail;
48721 }
48722 {
48723 resultobj = wxPyMake_wxObject(result, (bool)0);
48724 }
48725 return resultobj;
48726 fail:
48727 return NULL;
48728 }
48729
48730
48731 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48732 PyObject *resultobj = 0;
48733 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48734 wxButton *result = 0 ;
48735 void *argp1 = 0 ;
48736 int res1 = 0 ;
48737 PyObject *swig_obj[1] ;
48738
48739 if (!args) SWIG_fail;
48740 swig_obj[0] = args;
48741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48742 if (!SWIG_IsOK(res1)) {
48743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48744 }
48745 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48746 {
48747 PyThreadState* __tstate = wxPyBeginAllowThreads();
48748 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48749 wxPyEndAllowThreads(__tstate);
48750 if (PyErr_Occurred()) SWIG_fail;
48751 }
48752 {
48753 resultobj = wxPyMake_wxObject(result, (bool)0);
48754 }
48755 return resultobj;
48756 fail:
48757 return NULL;
48758 }
48759
48760
48761 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48762 PyObject *resultobj = 0;
48763 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48764 wxButton *result = 0 ;
48765 void *argp1 = 0 ;
48766 int res1 = 0 ;
48767 PyObject *swig_obj[1] ;
48768
48769 if (!args) SWIG_fail;
48770 swig_obj[0] = args;
48771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48772 if (!SWIG_IsOK(res1)) {
48773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48774 }
48775 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48776 {
48777 PyThreadState* __tstate = wxPyBeginAllowThreads();
48778 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48779 wxPyEndAllowThreads(__tstate);
48780 if (PyErr_Occurred()) SWIG_fail;
48781 }
48782 {
48783 resultobj = wxPyMake_wxObject(result, (bool)0);
48784 }
48785 return resultobj;
48786 fail:
48787 return NULL;
48788 }
48789
48790
48791 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48792 PyObject *resultobj = 0;
48793 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48794 wxButton *result = 0 ;
48795 void *argp1 = 0 ;
48796 int res1 = 0 ;
48797 PyObject *swig_obj[1] ;
48798
48799 if (!args) SWIG_fail;
48800 swig_obj[0] = args;
48801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48802 if (!SWIG_IsOK(res1)) {
48803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48804 }
48805 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48806 {
48807 PyThreadState* __tstate = wxPyBeginAllowThreads();
48808 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48809 wxPyEndAllowThreads(__tstate);
48810 if (PyErr_Occurred()) SWIG_fail;
48811 }
48812 {
48813 resultobj = wxPyMake_wxObject(result, (bool)0);
48814 }
48815 return resultobj;
48816 fail:
48817 return NULL;
48818 }
48819
48820
48821 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48822 PyObject *resultobj = 0;
48823 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48824 wxButton *result = 0 ;
48825 void *argp1 = 0 ;
48826 int res1 = 0 ;
48827 PyObject *swig_obj[1] ;
48828
48829 if (!args) SWIG_fail;
48830 swig_obj[0] = args;
48831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48832 if (!SWIG_IsOK(res1)) {
48833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48834 }
48835 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48836 {
48837 PyThreadState* __tstate = wxPyBeginAllowThreads();
48838 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48839 wxPyEndAllowThreads(__tstate);
48840 if (PyErr_Occurred()) SWIG_fail;
48841 }
48842 {
48843 resultobj = wxPyMake_wxObject(result, (bool)0);
48844 }
48845 return resultobj;
48846 fail:
48847 return NULL;
48848 }
48849
48850
48851 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48852 PyObject *obj;
48853 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48854 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48855 return SWIG_Py_Void();
48856 }
48857
48858 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48859 return SWIG_Python_InitShadowInstance(args);
48860 }
48861
48862 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48863 PyObject *resultobj = 0;
48864 int arg1 = (int) 0 ;
48865 int arg2 = (int) 0 ;
48866 wxGBPosition *result = 0 ;
48867 int val1 ;
48868 int ecode1 = 0 ;
48869 int val2 ;
48870 int ecode2 = 0 ;
48871 PyObject * obj0 = 0 ;
48872 PyObject * obj1 = 0 ;
48873 char * kwnames[] = {
48874 (char *) "row",(char *) "col", NULL
48875 };
48876
48877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48878 if (obj0) {
48879 ecode1 = SWIG_AsVal_int(obj0, &val1);
48880 if (!SWIG_IsOK(ecode1)) {
48881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48882 }
48883 arg1 = static_cast< int >(val1);
48884 }
48885 if (obj1) {
48886 ecode2 = SWIG_AsVal_int(obj1, &val2);
48887 if (!SWIG_IsOK(ecode2)) {
48888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48889 }
48890 arg2 = static_cast< int >(val2);
48891 }
48892 {
48893 PyThreadState* __tstate = wxPyBeginAllowThreads();
48894 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48895 wxPyEndAllowThreads(__tstate);
48896 if (PyErr_Occurred()) SWIG_fail;
48897 }
48898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48899 return resultobj;
48900 fail:
48901 return NULL;
48902 }
48903
48904
48905 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48906 PyObject *resultobj = 0;
48907 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48908 void *argp1 = 0 ;
48909 int res1 = 0 ;
48910 PyObject *swig_obj[1] ;
48911
48912 if (!args) SWIG_fail;
48913 swig_obj[0] = args;
48914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48915 if (!SWIG_IsOK(res1)) {
48916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48917 }
48918 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48919 {
48920 PyThreadState* __tstate = wxPyBeginAllowThreads();
48921 delete arg1;
48922
48923 wxPyEndAllowThreads(__tstate);
48924 if (PyErr_Occurred()) SWIG_fail;
48925 }
48926 resultobj = SWIG_Py_Void();
48927 return resultobj;
48928 fail:
48929 return NULL;
48930 }
48931
48932
48933 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48934 PyObject *resultobj = 0;
48935 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48936 int result;
48937 void *argp1 = 0 ;
48938 int res1 = 0 ;
48939 PyObject *swig_obj[1] ;
48940
48941 if (!args) SWIG_fail;
48942 swig_obj[0] = args;
48943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48944 if (!SWIG_IsOK(res1)) {
48945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48946 }
48947 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48948 {
48949 PyThreadState* __tstate = wxPyBeginAllowThreads();
48950 result = (int)((wxGBPosition const *)arg1)->GetRow();
48951 wxPyEndAllowThreads(__tstate);
48952 if (PyErr_Occurred()) SWIG_fail;
48953 }
48954 resultobj = SWIG_From_int(static_cast< int >(result));
48955 return resultobj;
48956 fail:
48957 return NULL;
48958 }
48959
48960
48961 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48962 PyObject *resultobj = 0;
48963 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48964 int result;
48965 void *argp1 = 0 ;
48966 int res1 = 0 ;
48967 PyObject *swig_obj[1] ;
48968
48969 if (!args) SWIG_fail;
48970 swig_obj[0] = args;
48971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48972 if (!SWIG_IsOK(res1)) {
48973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48974 }
48975 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48976 {
48977 PyThreadState* __tstate = wxPyBeginAllowThreads();
48978 result = (int)((wxGBPosition const *)arg1)->GetCol();
48979 wxPyEndAllowThreads(__tstate);
48980 if (PyErr_Occurred()) SWIG_fail;
48981 }
48982 resultobj = SWIG_From_int(static_cast< int >(result));
48983 return resultobj;
48984 fail:
48985 return NULL;
48986 }
48987
48988
48989 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48990 PyObject *resultobj = 0;
48991 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48992 int arg2 ;
48993 void *argp1 = 0 ;
48994 int res1 = 0 ;
48995 int val2 ;
48996 int ecode2 = 0 ;
48997 PyObject * obj0 = 0 ;
48998 PyObject * obj1 = 0 ;
48999 char * kwnames[] = {
49000 (char *) "self",(char *) "row", NULL
49001 };
49002
49003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49005 if (!SWIG_IsOK(res1)) {
49006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49007 }
49008 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49009 ecode2 = SWIG_AsVal_int(obj1, &val2);
49010 if (!SWIG_IsOK(ecode2)) {
49011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49012 }
49013 arg2 = static_cast< int >(val2);
49014 {
49015 PyThreadState* __tstate = wxPyBeginAllowThreads();
49016 (arg1)->SetRow(arg2);
49017 wxPyEndAllowThreads(__tstate);
49018 if (PyErr_Occurred()) SWIG_fail;
49019 }
49020 resultobj = SWIG_Py_Void();
49021 return resultobj;
49022 fail:
49023 return NULL;
49024 }
49025
49026
49027 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49028 PyObject *resultobj = 0;
49029 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49030 int arg2 ;
49031 void *argp1 = 0 ;
49032 int res1 = 0 ;
49033 int val2 ;
49034 int ecode2 = 0 ;
49035 PyObject * obj0 = 0 ;
49036 PyObject * obj1 = 0 ;
49037 char * kwnames[] = {
49038 (char *) "self",(char *) "col", NULL
49039 };
49040
49041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49043 if (!SWIG_IsOK(res1)) {
49044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49045 }
49046 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49047 ecode2 = SWIG_AsVal_int(obj1, &val2);
49048 if (!SWIG_IsOK(ecode2)) {
49049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49050 }
49051 arg2 = static_cast< int >(val2);
49052 {
49053 PyThreadState* __tstate = wxPyBeginAllowThreads();
49054 (arg1)->SetCol(arg2);
49055 wxPyEndAllowThreads(__tstate);
49056 if (PyErr_Occurred()) SWIG_fail;
49057 }
49058 resultobj = SWIG_Py_Void();
49059 return resultobj;
49060 fail:
49061 return NULL;
49062 }
49063
49064
49065 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49066 PyObject *resultobj = 0;
49067 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49068 PyObject *arg2 = (PyObject *) 0 ;
49069 bool result;
49070 void *argp1 = 0 ;
49071 int res1 = 0 ;
49072 PyObject * obj0 = 0 ;
49073 PyObject * obj1 = 0 ;
49074 char * kwnames[] = {
49075 (char *) "self",(char *) "other", NULL
49076 };
49077
49078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49080 if (!SWIG_IsOK(res1)) {
49081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49082 }
49083 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49084 arg2 = obj1;
49085 {
49086 result = (bool)wxGBPosition___eq__(arg1,arg2);
49087 if (PyErr_Occurred()) SWIG_fail;
49088 }
49089 {
49090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49091 }
49092 return resultobj;
49093 fail:
49094 return NULL;
49095 }
49096
49097
49098 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49099 PyObject *resultobj = 0;
49100 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49101 PyObject *arg2 = (PyObject *) 0 ;
49102 bool result;
49103 void *argp1 = 0 ;
49104 int res1 = 0 ;
49105 PyObject * obj0 = 0 ;
49106 PyObject * obj1 = 0 ;
49107 char * kwnames[] = {
49108 (char *) "self",(char *) "other", NULL
49109 };
49110
49111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49113 if (!SWIG_IsOK(res1)) {
49114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49115 }
49116 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49117 arg2 = obj1;
49118 {
49119 result = (bool)wxGBPosition___ne__(arg1,arg2);
49120 if (PyErr_Occurred()) SWIG_fail;
49121 }
49122 {
49123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49124 }
49125 return resultobj;
49126 fail:
49127 return NULL;
49128 }
49129
49130
49131 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49132 PyObject *resultobj = 0;
49133 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49134 int arg2 = (int) 0 ;
49135 int arg3 = (int) 0 ;
49136 void *argp1 = 0 ;
49137 int res1 = 0 ;
49138 int val2 ;
49139 int ecode2 = 0 ;
49140 int val3 ;
49141 int ecode3 = 0 ;
49142 PyObject * obj0 = 0 ;
49143 PyObject * obj1 = 0 ;
49144 PyObject * obj2 = 0 ;
49145 char * kwnames[] = {
49146 (char *) "self",(char *) "row",(char *) "col", NULL
49147 };
49148
49149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49151 if (!SWIG_IsOK(res1)) {
49152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49153 }
49154 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49155 if (obj1) {
49156 ecode2 = SWIG_AsVal_int(obj1, &val2);
49157 if (!SWIG_IsOK(ecode2)) {
49158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49159 }
49160 arg2 = static_cast< int >(val2);
49161 }
49162 if (obj2) {
49163 ecode3 = SWIG_AsVal_int(obj2, &val3);
49164 if (!SWIG_IsOK(ecode3)) {
49165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49166 }
49167 arg3 = static_cast< int >(val3);
49168 }
49169 {
49170 PyThreadState* __tstate = wxPyBeginAllowThreads();
49171 wxGBPosition_Set(arg1,arg2,arg3);
49172 wxPyEndAllowThreads(__tstate);
49173 if (PyErr_Occurred()) SWIG_fail;
49174 }
49175 resultobj = SWIG_Py_Void();
49176 return resultobj;
49177 fail:
49178 return NULL;
49179 }
49180
49181
49182 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49183 PyObject *resultobj = 0;
49184 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49185 PyObject *result = 0 ;
49186 void *argp1 = 0 ;
49187 int res1 = 0 ;
49188 PyObject *swig_obj[1] ;
49189
49190 if (!args) SWIG_fail;
49191 swig_obj[0] = args;
49192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49193 if (!SWIG_IsOK(res1)) {
49194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49195 }
49196 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49197 {
49198 PyThreadState* __tstate = wxPyBeginAllowThreads();
49199 result = (PyObject *)wxGBPosition_Get(arg1);
49200 wxPyEndAllowThreads(__tstate);
49201 if (PyErr_Occurred()) SWIG_fail;
49202 }
49203 resultobj = result;
49204 return resultobj;
49205 fail:
49206 return NULL;
49207 }
49208
49209
49210 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49211 PyObject *obj;
49212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49213 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49214 return SWIG_Py_Void();
49215 }
49216
49217 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49218 return SWIG_Python_InitShadowInstance(args);
49219 }
49220
49221 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49222 PyObject *resultobj = 0;
49223 int arg1 = (int) 1 ;
49224 int arg2 = (int) 1 ;
49225 wxGBSpan *result = 0 ;
49226 int val1 ;
49227 int ecode1 = 0 ;
49228 int val2 ;
49229 int ecode2 = 0 ;
49230 PyObject * obj0 = 0 ;
49231 PyObject * obj1 = 0 ;
49232 char * kwnames[] = {
49233 (char *) "rowspan",(char *) "colspan", NULL
49234 };
49235
49236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49237 if (obj0) {
49238 ecode1 = SWIG_AsVal_int(obj0, &val1);
49239 if (!SWIG_IsOK(ecode1)) {
49240 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49241 }
49242 arg1 = static_cast< int >(val1);
49243 }
49244 if (obj1) {
49245 ecode2 = SWIG_AsVal_int(obj1, &val2);
49246 if (!SWIG_IsOK(ecode2)) {
49247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49248 }
49249 arg2 = static_cast< int >(val2);
49250 }
49251 {
49252 PyThreadState* __tstate = wxPyBeginAllowThreads();
49253 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49254 wxPyEndAllowThreads(__tstate);
49255 if (PyErr_Occurred()) SWIG_fail;
49256 }
49257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49258 return resultobj;
49259 fail:
49260 return NULL;
49261 }
49262
49263
49264 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49265 PyObject *resultobj = 0;
49266 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49267 void *argp1 = 0 ;
49268 int res1 = 0 ;
49269 PyObject *swig_obj[1] ;
49270
49271 if (!args) SWIG_fail;
49272 swig_obj[0] = args;
49273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49274 if (!SWIG_IsOK(res1)) {
49275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49276 }
49277 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49278 {
49279 PyThreadState* __tstate = wxPyBeginAllowThreads();
49280 delete arg1;
49281
49282 wxPyEndAllowThreads(__tstate);
49283 if (PyErr_Occurred()) SWIG_fail;
49284 }
49285 resultobj = SWIG_Py_Void();
49286 return resultobj;
49287 fail:
49288 return NULL;
49289 }
49290
49291
49292 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49293 PyObject *resultobj = 0;
49294 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49295 int result;
49296 void *argp1 = 0 ;
49297 int res1 = 0 ;
49298 PyObject *swig_obj[1] ;
49299
49300 if (!args) SWIG_fail;
49301 swig_obj[0] = args;
49302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49303 if (!SWIG_IsOK(res1)) {
49304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49305 }
49306 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49307 {
49308 PyThreadState* __tstate = wxPyBeginAllowThreads();
49309 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49310 wxPyEndAllowThreads(__tstate);
49311 if (PyErr_Occurred()) SWIG_fail;
49312 }
49313 resultobj = SWIG_From_int(static_cast< int >(result));
49314 return resultobj;
49315 fail:
49316 return NULL;
49317 }
49318
49319
49320 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49321 PyObject *resultobj = 0;
49322 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49323 int result;
49324 void *argp1 = 0 ;
49325 int res1 = 0 ;
49326 PyObject *swig_obj[1] ;
49327
49328 if (!args) SWIG_fail;
49329 swig_obj[0] = args;
49330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49331 if (!SWIG_IsOK(res1)) {
49332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49333 }
49334 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49335 {
49336 PyThreadState* __tstate = wxPyBeginAllowThreads();
49337 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49338 wxPyEndAllowThreads(__tstate);
49339 if (PyErr_Occurred()) SWIG_fail;
49340 }
49341 resultobj = SWIG_From_int(static_cast< int >(result));
49342 return resultobj;
49343 fail:
49344 return NULL;
49345 }
49346
49347
49348 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49349 PyObject *resultobj = 0;
49350 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49351 int arg2 ;
49352 void *argp1 = 0 ;
49353 int res1 = 0 ;
49354 int val2 ;
49355 int ecode2 = 0 ;
49356 PyObject * obj0 = 0 ;
49357 PyObject * obj1 = 0 ;
49358 char * kwnames[] = {
49359 (char *) "self",(char *) "rowspan", NULL
49360 };
49361
49362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49364 if (!SWIG_IsOK(res1)) {
49365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49366 }
49367 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49368 ecode2 = SWIG_AsVal_int(obj1, &val2);
49369 if (!SWIG_IsOK(ecode2)) {
49370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49371 }
49372 arg2 = static_cast< int >(val2);
49373 {
49374 PyThreadState* __tstate = wxPyBeginAllowThreads();
49375 (arg1)->SetRowspan(arg2);
49376 wxPyEndAllowThreads(__tstate);
49377 if (PyErr_Occurred()) SWIG_fail;
49378 }
49379 resultobj = SWIG_Py_Void();
49380 return resultobj;
49381 fail:
49382 return NULL;
49383 }
49384
49385
49386 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49387 PyObject *resultobj = 0;
49388 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49389 int arg2 ;
49390 void *argp1 = 0 ;
49391 int res1 = 0 ;
49392 int val2 ;
49393 int ecode2 = 0 ;
49394 PyObject * obj0 = 0 ;
49395 PyObject * obj1 = 0 ;
49396 char * kwnames[] = {
49397 (char *) "self",(char *) "colspan", NULL
49398 };
49399
49400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49402 if (!SWIG_IsOK(res1)) {
49403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49404 }
49405 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49406 ecode2 = SWIG_AsVal_int(obj1, &val2);
49407 if (!SWIG_IsOK(ecode2)) {
49408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49409 }
49410 arg2 = static_cast< int >(val2);
49411 {
49412 PyThreadState* __tstate = wxPyBeginAllowThreads();
49413 (arg1)->SetColspan(arg2);
49414 wxPyEndAllowThreads(__tstate);
49415 if (PyErr_Occurred()) SWIG_fail;
49416 }
49417 resultobj = SWIG_Py_Void();
49418 return resultobj;
49419 fail:
49420 return NULL;
49421 }
49422
49423
49424 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49425 PyObject *resultobj = 0;
49426 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49427 PyObject *arg2 = (PyObject *) 0 ;
49428 bool result;
49429 void *argp1 = 0 ;
49430 int res1 = 0 ;
49431 PyObject * obj0 = 0 ;
49432 PyObject * obj1 = 0 ;
49433 char * kwnames[] = {
49434 (char *) "self",(char *) "other", NULL
49435 };
49436
49437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49439 if (!SWIG_IsOK(res1)) {
49440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49441 }
49442 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49443 arg2 = obj1;
49444 {
49445 result = (bool)wxGBSpan___eq__(arg1,arg2);
49446 if (PyErr_Occurred()) SWIG_fail;
49447 }
49448 {
49449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49450 }
49451 return resultobj;
49452 fail:
49453 return NULL;
49454 }
49455
49456
49457 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49458 PyObject *resultobj = 0;
49459 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49460 PyObject *arg2 = (PyObject *) 0 ;
49461 bool result;
49462 void *argp1 = 0 ;
49463 int res1 = 0 ;
49464 PyObject * obj0 = 0 ;
49465 PyObject * obj1 = 0 ;
49466 char * kwnames[] = {
49467 (char *) "self",(char *) "other", NULL
49468 };
49469
49470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49472 if (!SWIG_IsOK(res1)) {
49473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49474 }
49475 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49476 arg2 = obj1;
49477 {
49478 result = (bool)wxGBSpan___ne__(arg1,arg2);
49479 if (PyErr_Occurred()) SWIG_fail;
49480 }
49481 {
49482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49483 }
49484 return resultobj;
49485 fail:
49486 return NULL;
49487 }
49488
49489
49490 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49491 PyObject *resultobj = 0;
49492 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49493 int arg2 = (int) 1 ;
49494 int arg3 = (int) 1 ;
49495 void *argp1 = 0 ;
49496 int res1 = 0 ;
49497 int val2 ;
49498 int ecode2 = 0 ;
49499 int val3 ;
49500 int ecode3 = 0 ;
49501 PyObject * obj0 = 0 ;
49502 PyObject * obj1 = 0 ;
49503 PyObject * obj2 = 0 ;
49504 char * kwnames[] = {
49505 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49506 };
49507
49508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49510 if (!SWIG_IsOK(res1)) {
49511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49512 }
49513 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49514 if (obj1) {
49515 ecode2 = SWIG_AsVal_int(obj1, &val2);
49516 if (!SWIG_IsOK(ecode2)) {
49517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49518 }
49519 arg2 = static_cast< int >(val2);
49520 }
49521 if (obj2) {
49522 ecode3 = SWIG_AsVal_int(obj2, &val3);
49523 if (!SWIG_IsOK(ecode3)) {
49524 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49525 }
49526 arg3 = static_cast< int >(val3);
49527 }
49528 {
49529 PyThreadState* __tstate = wxPyBeginAllowThreads();
49530 wxGBSpan_Set(arg1,arg2,arg3);
49531 wxPyEndAllowThreads(__tstate);
49532 if (PyErr_Occurred()) SWIG_fail;
49533 }
49534 resultobj = SWIG_Py_Void();
49535 return resultobj;
49536 fail:
49537 return NULL;
49538 }
49539
49540
49541 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49542 PyObject *resultobj = 0;
49543 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49544 PyObject *result = 0 ;
49545 void *argp1 = 0 ;
49546 int res1 = 0 ;
49547 PyObject *swig_obj[1] ;
49548
49549 if (!args) SWIG_fail;
49550 swig_obj[0] = args;
49551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49552 if (!SWIG_IsOK(res1)) {
49553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49554 }
49555 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49556 {
49557 PyThreadState* __tstate = wxPyBeginAllowThreads();
49558 result = (PyObject *)wxGBSpan_Get(arg1);
49559 wxPyEndAllowThreads(__tstate);
49560 if (PyErr_Occurred()) SWIG_fail;
49561 }
49562 resultobj = result;
49563 return resultobj;
49564 fail:
49565 return NULL;
49566 }
49567
49568
49569 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49570 PyObject *obj;
49571 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49572 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49573 return SWIG_Py_Void();
49574 }
49575
49576 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49577 return SWIG_Python_InitShadowInstance(args);
49578 }
49579
49580 SWIGINTERN int DefaultSpan_set(PyObject *) {
49581 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49582 return 1;
49583 }
49584
49585
49586 SWIGINTERN PyObject *DefaultSpan_get(void) {
49587 PyObject *pyobj = 0;
49588
49589 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49590 return pyobj;
49591 }
49592
49593
49594 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49595 PyObject *resultobj = 0;
49596 wxGBSizerItem *result = 0 ;
49597
49598 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49599 {
49600 PyThreadState* __tstate = wxPyBeginAllowThreads();
49601 result = (wxGBSizerItem *)new wxGBSizerItem();
49602 wxPyEndAllowThreads(__tstate);
49603 if (PyErr_Occurred()) SWIG_fail;
49604 }
49605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49606 return resultobj;
49607 fail:
49608 return NULL;
49609 }
49610
49611
49612 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49613 PyObject *resultobj = 0;
49614 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49615 void *argp1 = 0 ;
49616 int res1 = 0 ;
49617 PyObject *swig_obj[1] ;
49618
49619 if (!args) SWIG_fail;
49620 swig_obj[0] = args;
49621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49622 if (!SWIG_IsOK(res1)) {
49623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49624 }
49625 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49626 {
49627 PyThreadState* __tstate = wxPyBeginAllowThreads();
49628 delete arg1;
49629
49630 wxPyEndAllowThreads(__tstate);
49631 if (PyErr_Occurred()) SWIG_fail;
49632 }
49633 resultobj = SWIG_Py_Void();
49634 return resultobj;
49635 fail:
49636 return NULL;
49637 }
49638
49639
49640 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49641 PyObject *resultobj = 0;
49642 wxWindow *arg1 = (wxWindow *) 0 ;
49643 wxGBPosition *arg2 = 0 ;
49644 wxGBSpan *arg3 = 0 ;
49645 int arg4 ;
49646 int arg5 ;
49647 PyObject *arg6 = (PyObject *) NULL ;
49648 wxGBSizerItem *result = 0 ;
49649 void *argp1 = 0 ;
49650 int res1 = 0 ;
49651 wxGBPosition temp2 ;
49652 wxGBSpan temp3 ;
49653 int val4 ;
49654 int ecode4 = 0 ;
49655 int val5 ;
49656 int ecode5 = 0 ;
49657 PyObject * obj0 = 0 ;
49658 PyObject * obj1 = 0 ;
49659 PyObject * obj2 = 0 ;
49660 PyObject * obj3 = 0 ;
49661 PyObject * obj4 = 0 ;
49662 PyObject * obj5 = 0 ;
49663 char * kwnames[] = {
49664 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49665 };
49666
49667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49669 if (!SWIG_IsOK(res1)) {
49670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49671 }
49672 arg1 = reinterpret_cast< wxWindow * >(argp1);
49673 {
49674 arg2 = &temp2;
49675 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49676 }
49677 {
49678 arg3 = &temp3;
49679 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49680 }
49681 ecode4 = SWIG_AsVal_int(obj3, &val4);
49682 if (!SWIG_IsOK(ecode4)) {
49683 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49684 }
49685 arg4 = static_cast< int >(val4);
49686 ecode5 = SWIG_AsVal_int(obj4, &val5);
49687 if (!SWIG_IsOK(ecode5)) {
49688 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49689 }
49690 arg5 = static_cast< int >(val5);
49691 if (obj5) {
49692 arg6 = obj5;
49693 }
49694 {
49695 PyThreadState* __tstate = wxPyBeginAllowThreads();
49696 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49697 wxPyEndAllowThreads(__tstate);
49698 if (PyErr_Occurred()) SWIG_fail;
49699 }
49700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49701 return resultobj;
49702 fail:
49703 return NULL;
49704 }
49705
49706
49707 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49708 PyObject *resultobj = 0;
49709 wxSizer *arg1 = (wxSizer *) 0 ;
49710 wxGBPosition *arg2 = 0 ;
49711 wxGBSpan *arg3 = 0 ;
49712 int arg4 ;
49713 int arg5 ;
49714 PyObject *arg6 = (PyObject *) NULL ;
49715 wxGBSizerItem *result = 0 ;
49716 int res1 = 0 ;
49717 wxGBPosition temp2 ;
49718 wxGBSpan temp3 ;
49719 int val4 ;
49720 int ecode4 = 0 ;
49721 int val5 ;
49722 int ecode5 = 0 ;
49723 PyObject * obj0 = 0 ;
49724 PyObject * obj1 = 0 ;
49725 PyObject * obj2 = 0 ;
49726 PyObject * obj3 = 0 ;
49727 PyObject * obj4 = 0 ;
49728 PyObject * obj5 = 0 ;
49729 char * kwnames[] = {
49730 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49731 };
49732
49733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49734 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49735 if (!SWIG_IsOK(res1)) {
49736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49737 }
49738 {
49739 arg2 = &temp2;
49740 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49741 }
49742 {
49743 arg3 = &temp3;
49744 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49745 }
49746 ecode4 = SWIG_AsVal_int(obj3, &val4);
49747 if (!SWIG_IsOK(ecode4)) {
49748 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49749 }
49750 arg4 = static_cast< int >(val4);
49751 ecode5 = SWIG_AsVal_int(obj4, &val5);
49752 if (!SWIG_IsOK(ecode5)) {
49753 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49754 }
49755 arg5 = static_cast< int >(val5);
49756 if (obj5) {
49757 arg6 = obj5;
49758 }
49759 {
49760 PyThreadState* __tstate = wxPyBeginAllowThreads();
49761 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49762 wxPyEndAllowThreads(__tstate);
49763 if (PyErr_Occurred()) SWIG_fail;
49764 }
49765 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49766 return resultobj;
49767 fail:
49768 return NULL;
49769 }
49770
49771
49772 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49773 PyObject *resultobj = 0;
49774 int arg1 ;
49775 int arg2 ;
49776 wxGBPosition *arg3 = 0 ;
49777 wxGBSpan *arg4 = 0 ;
49778 int arg5 ;
49779 int arg6 ;
49780 PyObject *arg7 = (PyObject *) NULL ;
49781 wxGBSizerItem *result = 0 ;
49782 int val1 ;
49783 int ecode1 = 0 ;
49784 int val2 ;
49785 int ecode2 = 0 ;
49786 wxGBPosition temp3 ;
49787 wxGBSpan temp4 ;
49788 int val5 ;
49789 int ecode5 = 0 ;
49790 int val6 ;
49791 int ecode6 = 0 ;
49792 PyObject * obj0 = 0 ;
49793 PyObject * obj1 = 0 ;
49794 PyObject * obj2 = 0 ;
49795 PyObject * obj3 = 0 ;
49796 PyObject * obj4 = 0 ;
49797 PyObject * obj5 = 0 ;
49798 PyObject * obj6 = 0 ;
49799 char * kwnames[] = {
49800 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49801 };
49802
49803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49804 ecode1 = SWIG_AsVal_int(obj0, &val1);
49805 if (!SWIG_IsOK(ecode1)) {
49806 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49807 }
49808 arg1 = static_cast< int >(val1);
49809 ecode2 = SWIG_AsVal_int(obj1, &val2);
49810 if (!SWIG_IsOK(ecode2)) {
49811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49812 }
49813 arg2 = static_cast< int >(val2);
49814 {
49815 arg3 = &temp3;
49816 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49817 }
49818 {
49819 arg4 = &temp4;
49820 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49821 }
49822 ecode5 = SWIG_AsVal_int(obj4, &val5);
49823 if (!SWIG_IsOK(ecode5)) {
49824 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49825 }
49826 arg5 = static_cast< int >(val5);
49827 ecode6 = SWIG_AsVal_int(obj5, &val6);
49828 if (!SWIG_IsOK(ecode6)) {
49829 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49830 }
49831 arg6 = static_cast< int >(val6);
49832 if (obj6) {
49833 arg7 = obj6;
49834 }
49835 {
49836 PyThreadState* __tstate = wxPyBeginAllowThreads();
49837 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49838 wxPyEndAllowThreads(__tstate);
49839 if (PyErr_Occurred()) SWIG_fail;
49840 }
49841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49842 return resultobj;
49843 fail:
49844 return NULL;
49845 }
49846
49847
49848 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49849 PyObject *resultobj = 0;
49850 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49851 wxGBPosition result;
49852 void *argp1 = 0 ;
49853 int res1 = 0 ;
49854 PyObject *swig_obj[1] ;
49855
49856 if (!args) SWIG_fail;
49857 swig_obj[0] = args;
49858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49859 if (!SWIG_IsOK(res1)) {
49860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49861 }
49862 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49863 {
49864 PyThreadState* __tstate = wxPyBeginAllowThreads();
49865 result = ((wxGBSizerItem const *)arg1)->GetPos();
49866 wxPyEndAllowThreads(__tstate);
49867 if (PyErr_Occurred()) SWIG_fail;
49868 }
49869 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49870 return resultobj;
49871 fail:
49872 return NULL;
49873 }
49874
49875
49876 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49877 PyObject *resultobj = 0;
49878 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49879 wxGBSpan result;
49880 void *argp1 = 0 ;
49881 int res1 = 0 ;
49882 PyObject *swig_obj[1] ;
49883
49884 if (!args) SWIG_fail;
49885 swig_obj[0] = args;
49886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49887 if (!SWIG_IsOK(res1)) {
49888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49889 }
49890 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49891 {
49892 PyThreadState* __tstate = wxPyBeginAllowThreads();
49893 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49894 wxPyEndAllowThreads(__tstate);
49895 if (PyErr_Occurred()) SWIG_fail;
49896 }
49897 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49898 return resultobj;
49899 fail:
49900 return NULL;
49901 }
49902
49903
49904 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49905 PyObject *resultobj = 0;
49906 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49907 wxGBPosition *arg2 = 0 ;
49908 bool result;
49909 void *argp1 = 0 ;
49910 int res1 = 0 ;
49911 wxGBPosition temp2 ;
49912 PyObject * obj0 = 0 ;
49913 PyObject * obj1 = 0 ;
49914 char * kwnames[] = {
49915 (char *) "self",(char *) "pos", NULL
49916 };
49917
49918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49920 if (!SWIG_IsOK(res1)) {
49921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49922 }
49923 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49924 {
49925 arg2 = &temp2;
49926 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49927 }
49928 {
49929 PyThreadState* __tstate = wxPyBeginAllowThreads();
49930 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49931 wxPyEndAllowThreads(__tstate);
49932 if (PyErr_Occurred()) SWIG_fail;
49933 }
49934 {
49935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49936 }
49937 return resultobj;
49938 fail:
49939 return NULL;
49940 }
49941
49942
49943 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49944 PyObject *resultobj = 0;
49945 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49946 wxGBSpan *arg2 = 0 ;
49947 bool result;
49948 void *argp1 = 0 ;
49949 int res1 = 0 ;
49950 wxGBSpan temp2 ;
49951 PyObject * obj0 = 0 ;
49952 PyObject * obj1 = 0 ;
49953 char * kwnames[] = {
49954 (char *) "self",(char *) "span", NULL
49955 };
49956
49957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49959 if (!SWIG_IsOK(res1)) {
49960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49961 }
49962 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49963 {
49964 arg2 = &temp2;
49965 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49966 }
49967 {
49968 PyThreadState* __tstate = wxPyBeginAllowThreads();
49969 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49970 wxPyEndAllowThreads(__tstate);
49971 if (PyErr_Occurred()) SWIG_fail;
49972 }
49973 {
49974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49975 }
49976 return resultobj;
49977 fail:
49978 return NULL;
49979 }
49980
49981
49982 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49983 PyObject *resultobj = 0;
49984 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49985 wxGBSizerItem *arg2 = 0 ;
49986 bool result;
49987 void *argp1 = 0 ;
49988 int res1 = 0 ;
49989 void *argp2 = 0 ;
49990 int res2 = 0 ;
49991 PyObject * obj0 = 0 ;
49992 PyObject * obj1 = 0 ;
49993 char * kwnames[] = {
49994 (char *) "self",(char *) "other", NULL
49995 };
49996
49997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49999 if (!SWIG_IsOK(res1)) {
50000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50001 }
50002 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50003 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50004 if (!SWIG_IsOK(res2)) {
50005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50006 }
50007 if (!argp2) {
50008 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50009 }
50010 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50011 {
50012 PyThreadState* __tstate = wxPyBeginAllowThreads();
50013 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50014 wxPyEndAllowThreads(__tstate);
50015 if (PyErr_Occurred()) SWIG_fail;
50016 }
50017 {
50018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50019 }
50020 return resultobj;
50021 fail:
50022 return NULL;
50023 }
50024
50025
50026 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50027 PyObject *resultobj = 0;
50028 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50029 wxGBPosition *arg2 = 0 ;
50030 wxGBSpan *arg3 = 0 ;
50031 bool result;
50032 void *argp1 = 0 ;
50033 int res1 = 0 ;
50034 wxGBPosition temp2 ;
50035 wxGBSpan temp3 ;
50036 PyObject * obj0 = 0 ;
50037 PyObject * obj1 = 0 ;
50038 PyObject * obj2 = 0 ;
50039 char * kwnames[] = {
50040 (char *) "self",(char *) "pos",(char *) "span", NULL
50041 };
50042
50043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50045 if (!SWIG_IsOK(res1)) {
50046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50047 }
50048 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50049 {
50050 arg2 = &temp2;
50051 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50052 }
50053 {
50054 arg3 = &temp3;
50055 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50056 }
50057 {
50058 PyThreadState* __tstate = wxPyBeginAllowThreads();
50059 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50060 wxPyEndAllowThreads(__tstate);
50061 if (PyErr_Occurred()) SWIG_fail;
50062 }
50063 {
50064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50065 }
50066 return resultobj;
50067 fail:
50068 return NULL;
50069 }
50070
50071
50072 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50073 PyObject *resultobj = 0;
50074 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50075 wxGBPosition result;
50076 void *argp1 = 0 ;
50077 int res1 = 0 ;
50078 PyObject *swig_obj[1] ;
50079
50080 if (!args) SWIG_fail;
50081 swig_obj[0] = args;
50082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50083 if (!SWIG_IsOK(res1)) {
50084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50085 }
50086 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50087 {
50088 PyThreadState* __tstate = wxPyBeginAllowThreads();
50089 result = wxGBSizerItem_GetEndPos(arg1);
50090 wxPyEndAllowThreads(__tstate);
50091 if (PyErr_Occurred()) SWIG_fail;
50092 }
50093 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50094 return resultobj;
50095 fail:
50096 return NULL;
50097 }
50098
50099
50100 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50101 PyObject *resultobj = 0;
50102 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50103 wxGridBagSizer *result = 0 ;
50104 void *argp1 = 0 ;
50105 int res1 = 0 ;
50106 PyObject *swig_obj[1] ;
50107
50108 if (!args) SWIG_fail;
50109 swig_obj[0] = args;
50110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50111 if (!SWIG_IsOK(res1)) {
50112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50113 }
50114 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50115 {
50116 PyThreadState* __tstate = wxPyBeginAllowThreads();
50117 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50118 wxPyEndAllowThreads(__tstate);
50119 if (PyErr_Occurred()) SWIG_fail;
50120 }
50121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50122 return resultobj;
50123 fail:
50124 return NULL;
50125 }
50126
50127
50128 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50129 PyObject *resultobj = 0;
50130 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50131 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50132 void *argp1 = 0 ;
50133 int res1 = 0 ;
50134 void *argp2 = 0 ;
50135 int res2 = 0 ;
50136 PyObject * obj0 = 0 ;
50137 PyObject * obj1 = 0 ;
50138 char * kwnames[] = {
50139 (char *) "self",(char *) "sizer", NULL
50140 };
50141
50142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50144 if (!SWIG_IsOK(res1)) {
50145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50146 }
50147 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50149 if (!SWIG_IsOK(res2)) {
50150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50151 }
50152 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50153 {
50154 PyThreadState* __tstate = wxPyBeginAllowThreads();
50155 (arg1)->SetGBSizer(arg2);
50156 wxPyEndAllowThreads(__tstate);
50157 if (PyErr_Occurred()) SWIG_fail;
50158 }
50159 resultobj = SWIG_Py_Void();
50160 return resultobj;
50161 fail:
50162 return NULL;
50163 }
50164
50165
50166 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50167 PyObject *obj;
50168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50169 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50170 return SWIG_Py_Void();
50171 }
50172
50173 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50174 return SWIG_Python_InitShadowInstance(args);
50175 }
50176
50177 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50178 PyObject *resultobj = 0;
50179 int arg1 = (int) 0 ;
50180 int arg2 = (int) 0 ;
50181 wxGridBagSizer *result = 0 ;
50182 int val1 ;
50183 int ecode1 = 0 ;
50184 int val2 ;
50185 int ecode2 = 0 ;
50186 PyObject * obj0 = 0 ;
50187 PyObject * obj1 = 0 ;
50188 char * kwnames[] = {
50189 (char *) "vgap",(char *) "hgap", NULL
50190 };
50191
50192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50193 if (obj0) {
50194 ecode1 = SWIG_AsVal_int(obj0, &val1);
50195 if (!SWIG_IsOK(ecode1)) {
50196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50197 }
50198 arg1 = static_cast< int >(val1);
50199 }
50200 if (obj1) {
50201 ecode2 = SWIG_AsVal_int(obj1, &val2);
50202 if (!SWIG_IsOK(ecode2)) {
50203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50204 }
50205 arg2 = static_cast< int >(val2);
50206 }
50207 {
50208 PyThreadState* __tstate = wxPyBeginAllowThreads();
50209 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50210 wxPyEndAllowThreads(__tstate);
50211 if (PyErr_Occurred()) SWIG_fail;
50212 }
50213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50214 return resultobj;
50215 fail:
50216 return NULL;
50217 }
50218
50219
50220 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50221 PyObject *resultobj = 0;
50222 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50223 PyObject *arg2 = (PyObject *) 0 ;
50224 wxGBPosition *arg3 = 0 ;
50225 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50226 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50227 int arg5 = (int) 0 ;
50228 int arg6 = (int) 0 ;
50229 PyObject *arg7 = (PyObject *) NULL ;
50230 wxGBSizerItem *result = 0 ;
50231 void *argp1 = 0 ;
50232 int res1 = 0 ;
50233 wxGBPosition temp3 ;
50234 wxGBSpan temp4 ;
50235 int val5 ;
50236 int ecode5 = 0 ;
50237 int val6 ;
50238 int ecode6 = 0 ;
50239 PyObject * obj0 = 0 ;
50240 PyObject * obj1 = 0 ;
50241 PyObject * obj2 = 0 ;
50242 PyObject * obj3 = 0 ;
50243 PyObject * obj4 = 0 ;
50244 PyObject * obj5 = 0 ;
50245 PyObject * obj6 = 0 ;
50246 char * kwnames[] = {
50247 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50248 };
50249
50250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50252 if (!SWIG_IsOK(res1)) {
50253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50254 }
50255 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50256 arg2 = obj1;
50257 {
50258 arg3 = &temp3;
50259 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50260 }
50261 if (obj3) {
50262 {
50263 arg4 = &temp4;
50264 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50265 }
50266 }
50267 if (obj4) {
50268 ecode5 = SWIG_AsVal_int(obj4, &val5);
50269 if (!SWIG_IsOK(ecode5)) {
50270 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50271 }
50272 arg5 = static_cast< int >(val5);
50273 }
50274 if (obj5) {
50275 ecode6 = SWIG_AsVal_int(obj5, &val6);
50276 if (!SWIG_IsOK(ecode6)) {
50277 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50278 }
50279 arg6 = static_cast< int >(val6);
50280 }
50281 if (obj6) {
50282 arg7 = obj6;
50283 }
50284 {
50285 PyThreadState* __tstate = wxPyBeginAllowThreads();
50286 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50287 wxPyEndAllowThreads(__tstate);
50288 if (PyErr_Occurred()) SWIG_fail;
50289 }
50290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50291 return resultobj;
50292 fail:
50293 return NULL;
50294 }
50295
50296
50297 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50298 PyObject *resultobj = 0;
50299 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50300 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50301 wxGBSizerItem *result = 0 ;
50302 void *argp1 = 0 ;
50303 int res1 = 0 ;
50304 int res2 = 0 ;
50305 PyObject * obj0 = 0 ;
50306 PyObject * obj1 = 0 ;
50307 char * kwnames[] = {
50308 (char *) "self",(char *) "item", NULL
50309 };
50310
50311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50313 if (!SWIG_IsOK(res1)) {
50314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50315 }
50316 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50317 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50318 if (!SWIG_IsOK(res2)) {
50319 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50320 }
50321 {
50322 PyThreadState* __tstate = wxPyBeginAllowThreads();
50323 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50324 wxPyEndAllowThreads(__tstate);
50325 if (PyErr_Occurred()) SWIG_fail;
50326 }
50327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50328 return resultobj;
50329 fail:
50330 return NULL;
50331 }
50332
50333
50334 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50335 PyObject *resultobj = 0;
50336 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50337 int arg2 ;
50338 int arg3 ;
50339 wxSize result;
50340 void *argp1 = 0 ;
50341 int res1 = 0 ;
50342 int val2 ;
50343 int ecode2 = 0 ;
50344 int val3 ;
50345 int ecode3 = 0 ;
50346 PyObject * obj0 = 0 ;
50347 PyObject * obj1 = 0 ;
50348 PyObject * obj2 = 0 ;
50349 char * kwnames[] = {
50350 (char *) "self",(char *) "row",(char *) "col", NULL
50351 };
50352
50353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50355 if (!SWIG_IsOK(res1)) {
50356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50357 }
50358 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50359 ecode2 = SWIG_AsVal_int(obj1, &val2);
50360 if (!SWIG_IsOK(ecode2)) {
50361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50362 }
50363 arg2 = static_cast< int >(val2);
50364 ecode3 = SWIG_AsVal_int(obj2, &val3);
50365 if (!SWIG_IsOK(ecode3)) {
50366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50367 }
50368 arg3 = static_cast< int >(val3);
50369 {
50370 PyThreadState* __tstate = wxPyBeginAllowThreads();
50371 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50372 wxPyEndAllowThreads(__tstate);
50373 if (PyErr_Occurred()) SWIG_fail;
50374 }
50375 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50376 return resultobj;
50377 fail:
50378 return NULL;
50379 }
50380
50381
50382 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50383 PyObject *resultobj = 0;
50384 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50385 wxSize result;
50386 void *argp1 = 0 ;
50387 int res1 = 0 ;
50388 PyObject *swig_obj[1] ;
50389
50390 if (!args) SWIG_fail;
50391 swig_obj[0] = args;
50392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50393 if (!SWIG_IsOK(res1)) {
50394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50395 }
50396 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50397 {
50398 PyThreadState* __tstate = wxPyBeginAllowThreads();
50399 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50400 wxPyEndAllowThreads(__tstate);
50401 if (PyErr_Occurred()) SWIG_fail;
50402 }
50403 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50404 return resultobj;
50405 fail:
50406 return NULL;
50407 }
50408
50409
50410 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50411 PyObject *resultobj = 0;
50412 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50413 wxSize *arg2 = 0 ;
50414 void *argp1 = 0 ;
50415 int res1 = 0 ;
50416 wxSize temp2 ;
50417 PyObject * obj0 = 0 ;
50418 PyObject * obj1 = 0 ;
50419 char * kwnames[] = {
50420 (char *) "self",(char *) "sz", NULL
50421 };
50422
50423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50425 if (!SWIG_IsOK(res1)) {
50426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50427 }
50428 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50429 {
50430 arg2 = &temp2;
50431 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50432 }
50433 {
50434 PyThreadState* __tstate = wxPyBeginAllowThreads();
50435 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50436 wxPyEndAllowThreads(__tstate);
50437 if (PyErr_Occurred()) SWIG_fail;
50438 }
50439 resultobj = SWIG_Py_Void();
50440 return resultobj;
50441 fail:
50442 return NULL;
50443 }
50444
50445
50446 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50447 PyObject *resultobj = 0;
50448 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50449 wxWindow *arg2 = (wxWindow *) 0 ;
50450 wxGBPosition result;
50451 void *argp1 = 0 ;
50452 int res1 = 0 ;
50453 void *argp2 = 0 ;
50454 int res2 = 0 ;
50455
50456 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50458 if (!SWIG_IsOK(res1)) {
50459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50460 }
50461 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50462 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50463 if (!SWIG_IsOK(res2)) {
50464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50465 }
50466 arg2 = reinterpret_cast< wxWindow * >(argp2);
50467 {
50468 PyThreadState* __tstate = wxPyBeginAllowThreads();
50469 result = (arg1)->GetItemPosition(arg2);
50470 wxPyEndAllowThreads(__tstate);
50471 if (PyErr_Occurred()) SWIG_fail;
50472 }
50473 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50474 return resultobj;
50475 fail:
50476 return NULL;
50477 }
50478
50479
50480 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50481 PyObject *resultobj = 0;
50482 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50483 wxSizer *arg2 = (wxSizer *) 0 ;
50484 wxGBPosition result;
50485 void *argp1 = 0 ;
50486 int res1 = 0 ;
50487 void *argp2 = 0 ;
50488 int res2 = 0 ;
50489
50490 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50492 if (!SWIG_IsOK(res1)) {
50493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50494 }
50495 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50496 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50497 if (!SWIG_IsOK(res2)) {
50498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50499 }
50500 arg2 = reinterpret_cast< wxSizer * >(argp2);
50501 {
50502 PyThreadState* __tstate = wxPyBeginAllowThreads();
50503 result = (arg1)->GetItemPosition(arg2);
50504 wxPyEndAllowThreads(__tstate);
50505 if (PyErr_Occurred()) SWIG_fail;
50506 }
50507 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50508 return resultobj;
50509 fail:
50510 return NULL;
50511 }
50512
50513
50514 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50515 PyObject *resultobj = 0;
50516 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50517 size_t arg2 ;
50518 wxGBPosition result;
50519 void *argp1 = 0 ;
50520 int res1 = 0 ;
50521 size_t val2 ;
50522 int ecode2 = 0 ;
50523
50524 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50526 if (!SWIG_IsOK(res1)) {
50527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50528 }
50529 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50530 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50531 if (!SWIG_IsOK(ecode2)) {
50532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50533 }
50534 arg2 = static_cast< size_t >(val2);
50535 {
50536 PyThreadState* __tstate = wxPyBeginAllowThreads();
50537 result = (arg1)->GetItemPosition(arg2);
50538 wxPyEndAllowThreads(__tstate);
50539 if (PyErr_Occurred()) SWIG_fail;
50540 }
50541 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50542 return resultobj;
50543 fail:
50544 return NULL;
50545 }
50546
50547
50548 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50549 int argc;
50550 PyObject *argv[3];
50551
50552 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50553 --argc;
50554 if (argc == 2) {
50555 int _v = 0;
50556 {
50557 void *vptr = 0;
50558 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50559 _v = SWIG_CheckState(res);
50560 }
50561 if (!_v) goto check_1;
50562 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50563 }
50564 check_1:
50565
50566 if (argc == 2) {
50567 int _v = 0;
50568 {
50569 void *vptr = 0;
50570 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50571 _v = SWIG_CheckState(res);
50572 }
50573 if (!_v) goto check_2;
50574 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50575 }
50576 check_2:
50577
50578 if (argc == 2) {
50579 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50580 }
50581
50582 fail:
50583 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50584 return NULL;
50585 }
50586
50587
50588 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50589 PyObject *resultobj = 0;
50590 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50591 wxWindow *arg2 = (wxWindow *) 0 ;
50592 wxGBPosition *arg3 = 0 ;
50593 bool result;
50594 void *argp1 = 0 ;
50595 int res1 = 0 ;
50596 void *argp2 = 0 ;
50597 int res2 = 0 ;
50598 wxGBPosition temp3 ;
50599
50600 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50602 if (!SWIG_IsOK(res1)) {
50603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50604 }
50605 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50606 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50607 if (!SWIG_IsOK(res2)) {
50608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50609 }
50610 arg2 = reinterpret_cast< wxWindow * >(argp2);
50611 {
50612 arg3 = &temp3;
50613 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50614 }
50615 {
50616 PyThreadState* __tstate = wxPyBeginAllowThreads();
50617 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50618 wxPyEndAllowThreads(__tstate);
50619 if (PyErr_Occurred()) SWIG_fail;
50620 }
50621 {
50622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50623 }
50624 return resultobj;
50625 fail:
50626 return NULL;
50627 }
50628
50629
50630 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50631 PyObject *resultobj = 0;
50632 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50633 wxSizer *arg2 = (wxSizer *) 0 ;
50634 wxGBPosition *arg3 = 0 ;
50635 bool result;
50636 void *argp1 = 0 ;
50637 int res1 = 0 ;
50638 void *argp2 = 0 ;
50639 int res2 = 0 ;
50640 wxGBPosition temp3 ;
50641
50642 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50644 if (!SWIG_IsOK(res1)) {
50645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50646 }
50647 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50648 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50649 if (!SWIG_IsOK(res2)) {
50650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50651 }
50652 arg2 = reinterpret_cast< wxSizer * >(argp2);
50653 {
50654 arg3 = &temp3;
50655 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50656 }
50657 {
50658 PyThreadState* __tstate = wxPyBeginAllowThreads();
50659 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50660 wxPyEndAllowThreads(__tstate);
50661 if (PyErr_Occurred()) SWIG_fail;
50662 }
50663 {
50664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50665 }
50666 return resultobj;
50667 fail:
50668 return NULL;
50669 }
50670
50671
50672 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50673 PyObject *resultobj = 0;
50674 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50675 size_t arg2 ;
50676 wxGBPosition *arg3 = 0 ;
50677 bool result;
50678 void *argp1 = 0 ;
50679 int res1 = 0 ;
50680 size_t val2 ;
50681 int ecode2 = 0 ;
50682 wxGBPosition temp3 ;
50683
50684 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50686 if (!SWIG_IsOK(res1)) {
50687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50688 }
50689 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50690 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50691 if (!SWIG_IsOK(ecode2)) {
50692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50693 }
50694 arg2 = static_cast< size_t >(val2);
50695 {
50696 arg3 = &temp3;
50697 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50698 }
50699 {
50700 PyThreadState* __tstate = wxPyBeginAllowThreads();
50701 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50702 wxPyEndAllowThreads(__tstate);
50703 if (PyErr_Occurred()) SWIG_fail;
50704 }
50705 {
50706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50707 }
50708 return resultobj;
50709 fail:
50710 return NULL;
50711 }
50712
50713
50714 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50715 int argc;
50716 PyObject *argv[4];
50717
50718 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50719 --argc;
50720 if (argc == 3) {
50721 int _v = 0;
50722 {
50723 void *vptr = 0;
50724 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50725 _v = SWIG_CheckState(res);
50726 }
50727 if (!_v) goto check_1;
50728 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50729 }
50730 check_1:
50731
50732 if (argc == 3) {
50733 int _v = 0;
50734 {
50735 void *vptr = 0;
50736 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50737 _v = SWIG_CheckState(res);
50738 }
50739 if (!_v) goto check_2;
50740 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50741 }
50742 check_2:
50743
50744 if (argc == 3) {
50745 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50746 }
50747
50748 fail:
50749 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50750 return NULL;
50751 }
50752
50753
50754 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50755 PyObject *resultobj = 0;
50756 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50757 wxWindow *arg2 = (wxWindow *) 0 ;
50758 wxGBSpan result;
50759 void *argp1 = 0 ;
50760 int res1 = 0 ;
50761 void *argp2 = 0 ;
50762 int res2 = 0 ;
50763
50764 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50766 if (!SWIG_IsOK(res1)) {
50767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50768 }
50769 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50770 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50771 if (!SWIG_IsOK(res2)) {
50772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50773 }
50774 arg2 = reinterpret_cast< wxWindow * >(argp2);
50775 {
50776 PyThreadState* __tstate = wxPyBeginAllowThreads();
50777 result = (arg1)->GetItemSpan(arg2);
50778 wxPyEndAllowThreads(__tstate);
50779 if (PyErr_Occurred()) SWIG_fail;
50780 }
50781 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50782 return resultobj;
50783 fail:
50784 return NULL;
50785 }
50786
50787
50788 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50789 PyObject *resultobj = 0;
50790 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50791 wxSizer *arg2 = (wxSizer *) 0 ;
50792 wxGBSpan result;
50793 void *argp1 = 0 ;
50794 int res1 = 0 ;
50795 void *argp2 = 0 ;
50796 int res2 = 0 ;
50797
50798 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50800 if (!SWIG_IsOK(res1)) {
50801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50802 }
50803 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50804 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50805 if (!SWIG_IsOK(res2)) {
50806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50807 }
50808 arg2 = reinterpret_cast< wxSizer * >(argp2);
50809 {
50810 PyThreadState* __tstate = wxPyBeginAllowThreads();
50811 result = (arg1)->GetItemSpan(arg2);
50812 wxPyEndAllowThreads(__tstate);
50813 if (PyErr_Occurred()) SWIG_fail;
50814 }
50815 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50816 return resultobj;
50817 fail:
50818 return NULL;
50819 }
50820
50821
50822 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50823 PyObject *resultobj = 0;
50824 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50825 size_t arg2 ;
50826 wxGBSpan result;
50827 void *argp1 = 0 ;
50828 int res1 = 0 ;
50829 size_t val2 ;
50830 int ecode2 = 0 ;
50831
50832 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50834 if (!SWIG_IsOK(res1)) {
50835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50836 }
50837 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50838 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50839 if (!SWIG_IsOK(ecode2)) {
50840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50841 }
50842 arg2 = static_cast< size_t >(val2);
50843 {
50844 PyThreadState* __tstate = wxPyBeginAllowThreads();
50845 result = (arg1)->GetItemSpan(arg2);
50846 wxPyEndAllowThreads(__tstate);
50847 if (PyErr_Occurred()) SWIG_fail;
50848 }
50849 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50850 return resultobj;
50851 fail:
50852 return NULL;
50853 }
50854
50855
50856 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50857 int argc;
50858 PyObject *argv[3];
50859
50860 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50861 --argc;
50862 if (argc == 2) {
50863 int _v = 0;
50864 {
50865 void *vptr = 0;
50866 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50867 _v = SWIG_CheckState(res);
50868 }
50869 if (!_v) goto check_1;
50870 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50871 }
50872 check_1:
50873
50874 if (argc == 2) {
50875 int _v = 0;
50876 {
50877 void *vptr = 0;
50878 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50879 _v = SWIG_CheckState(res);
50880 }
50881 if (!_v) goto check_2;
50882 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50883 }
50884 check_2:
50885
50886 if (argc == 2) {
50887 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50888 }
50889
50890 fail:
50891 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50892 return NULL;
50893 }
50894
50895
50896 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50897 PyObject *resultobj = 0;
50898 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50899 wxWindow *arg2 = (wxWindow *) 0 ;
50900 wxGBSpan *arg3 = 0 ;
50901 bool result;
50902 void *argp1 = 0 ;
50903 int res1 = 0 ;
50904 void *argp2 = 0 ;
50905 int res2 = 0 ;
50906 wxGBSpan temp3 ;
50907
50908 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50910 if (!SWIG_IsOK(res1)) {
50911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50912 }
50913 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50914 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50915 if (!SWIG_IsOK(res2)) {
50916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50917 }
50918 arg2 = reinterpret_cast< wxWindow * >(argp2);
50919 {
50920 arg3 = &temp3;
50921 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50922 }
50923 {
50924 PyThreadState* __tstate = wxPyBeginAllowThreads();
50925 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50926 wxPyEndAllowThreads(__tstate);
50927 if (PyErr_Occurred()) SWIG_fail;
50928 }
50929 {
50930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50931 }
50932 return resultobj;
50933 fail:
50934 return NULL;
50935 }
50936
50937
50938 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50939 PyObject *resultobj = 0;
50940 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50941 wxSizer *arg2 = (wxSizer *) 0 ;
50942 wxGBSpan *arg3 = 0 ;
50943 bool result;
50944 void *argp1 = 0 ;
50945 int res1 = 0 ;
50946 void *argp2 = 0 ;
50947 int res2 = 0 ;
50948 wxGBSpan temp3 ;
50949
50950 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50952 if (!SWIG_IsOK(res1)) {
50953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50954 }
50955 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50956 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50957 if (!SWIG_IsOK(res2)) {
50958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50959 }
50960 arg2 = reinterpret_cast< wxSizer * >(argp2);
50961 {
50962 arg3 = &temp3;
50963 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50964 }
50965 {
50966 PyThreadState* __tstate = wxPyBeginAllowThreads();
50967 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50968 wxPyEndAllowThreads(__tstate);
50969 if (PyErr_Occurred()) SWIG_fail;
50970 }
50971 {
50972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50973 }
50974 return resultobj;
50975 fail:
50976 return NULL;
50977 }
50978
50979
50980 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50981 PyObject *resultobj = 0;
50982 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50983 size_t arg2 ;
50984 wxGBSpan *arg3 = 0 ;
50985 bool result;
50986 void *argp1 = 0 ;
50987 int res1 = 0 ;
50988 size_t val2 ;
50989 int ecode2 = 0 ;
50990 wxGBSpan temp3 ;
50991
50992 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50994 if (!SWIG_IsOK(res1)) {
50995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50996 }
50997 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50998 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50999 if (!SWIG_IsOK(ecode2)) {
51000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51001 }
51002 arg2 = static_cast< size_t >(val2);
51003 {
51004 arg3 = &temp3;
51005 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51006 }
51007 {
51008 PyThreadState* __tstate = wxPyBeginAllowThreads();
51009 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51010 wxPyEndAllowThreads(__tstate);
51011 if (PyErr_Occurred()) SWIG_fail;
51012 }
51013 {
51014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51015 }
51016 return resultobj;
51017 fail:
51018 return NULL;
51019 }
51020
51021
51022 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51023 int argc;
51024 PyObject *argv[4];
51025
51026 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51027 --argc;
51028 if (argc == 3) {
51029 int _v = 0;
51030 {
51031 void *vptr = 0;
51032 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51033 _v = SWIG_CheckState(res);
51034 }
51035 if (!_v) goto check_1;
51036 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51037 }
51038 check_1:
51039
51040 if (argc == 3) {
51041 int _v = 0;
51042 {
51043 void *vptr = 0;
51044 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51045 _v = SWIG_CheckState(res);
51046 }
51047 if (!_v) goto check_2;
51048 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51049 }
51050 check_2:
51051
51052 if (argc == 3) {
51053 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51054 }
51055
51056 fail:
51057 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51058 return NULL;
51059 }
51060
51061
51062 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51063 PyObject *resultobj = 0;
51064 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51065 wxWindow *arg2 = (wxWindow *) 0 ;
51066 wxGBSizerItem *result = 0 ;
51067 void *argp1 = 0 ;
51068 int res1 = 0 ;
51069 void *argp2 = 0 ;
51070 int res2 = 0 ;
51071
51072 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51074 if (!SWIG_IsOK(res1)) {
51075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51076 }
51077 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51078 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51079 if (!SWIG_IsOK(res2)) {
51080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51081 }
51082 arg2 = reinterpret_cast< wxWindow * >(argp2);
51083 {
51084 PyThreadState* __tstate = wxPyBeginAllowThreads();
51085 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51086 wxPyEndAllowThreads(__tstate);
51087 if (PyErr_Occurred()) SWIG_fail;
51088 }
51089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51090 return resultobj;
51091 fail:
51092 return NULL;
51093 }
51094
51095
51096 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51097 PyObject *resultobj = 0;
51098 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51099 wxSizer *arg2 = (wxSizer *) 0 ;
51100 wxGBSizerItem *result = 0 ;
51101 void *argp1 = 0 ;
51102 int res1 = 0 ;
51103 void *argp2 = 0 ;
51104 int res2 = 0 ;
51105
51106 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51108 if (!SWIG_IsOK(res1)) {
51109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51110 }
51111 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51112 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51113 if (!SWIG_IsOK(res2)) {
51114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51115 }
51116 arg2 = reinterpret_cast< wxSizer * >(argp2);
51117 {
51118 PyThreadState* __tstate = wxPyBeginAllowThreads();
51119 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51120 wxPyEndAllowThreads(__tstate);
51121 if (PyErr_Occurred()) SWIG_fail;
51122 }
51123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51124 return resultobj;
51125 fail:
51126 return NULL;
51127 }
51128
51129
51130 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51131 int argc;
51132 PyObject *argv[3];
51133
51134 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51135 --argc;
51136 if (argc == 2) {
51137 int _v = 0;
51138 {
51139 void *vptr = 0;
51140 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51141 _v = SWIG_CheckState(res);
51142 }
51143 if (!_v) goto check_1;
51144 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51145 }
51146 check_1:
51147
51148 if (argc == 2) {
51149 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51150 }
51151
51152 fail:
51153 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51154 return NULL;
51155 }
51156
51157
51158 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51159 PyObject *resultobj = 0;
51160 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51161 wxGBPosition *arg2 = 0 ;
51162 wxGBSizerItem *result = 0 ;
51163 void *argp1 = 0 ;
51164 int res1 = 0 ;
51165 wxGBPosition temp2 ;
51166 PyObject * obj0 = 0 ;
51167 PyObject * obj1 = 0 ;
51168 char * kwnames[] = {
51169 (char *) "self",(char *) "pos", NULL
51170 };
51171
51172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51174 if (!SWIG_IsOK(res1)) {
51175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51176 }
51177 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51178 {
51179 arg2 = &temp2;
51180 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51181 }
51182 {
51183 PyThreadState* __tstate = wxPyBeginAllowThreads();
51184 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51185 wxPyEndAllowThreads(__tstate);
51186 if (PyErr_Occurred()) SWIG_fail;
51187 }
51188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51189 return resultobj;
51190 fail:
51191 return NULL;
51192 }
51193
51194
51195 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51196 PyObject *resultobj = 0;
51197 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51198 wxPoint *arg2 = 0 ;
51199 wxGBSizerItem *result = 0 ;
51200 void *argp1 = 0 ;
51201 int res1 = 0 ;
51202 wxPoint temp2 ;
51203 PyObject * obj0 = 0 ;
51204 PyObject * obj1 = 0 ;
51205 char * kwnames[] = {
51206 (char *) "self",(char *) "pt", NULL
51207 };
51208
51209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51211 if (!SWIG_IsOK(res1)) {
51212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51213 }
51214 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51215 {
51216 arg2 = &temp2;
51217 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51218 }
51219 {
51220 PyThreadState* __tstate = wxPyBeginAllowThreads();
51221 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51222 wxPyEndAllowThreads(__tstate);
51223 if (PyErr_Occurred()) SWIG_fail;
51224 }
51225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51226 return resultobj;
51227 fail:
51228 return NULL;
51229 }
51230
51231
51232 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51233 PyObject *resultobj = 0;
51234 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51235 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51236 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51237 bool result;
51238 void *argp1 = 0 ;
51239 int res1 = 0 ;
51240 void *argp2 = 0 ;
51241 int res2 = 0 ;
51242 void *argp3 = 0 ;
51243 int res3 = 0 ;
51244 PyObject * obj0 = 0 ;
51245 PyObject * obj1 = 0 ;
51246 PyObject * obj2 = 0 ;
51247 char * kwnames[] = {
51248 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51249 };
51250
51251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51253 if (!SWIG_IsOK(res1)) {
51254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51255 }
51256 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51258 if (!SWIG_IsOK(res2)) {
51259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51260 }
51261 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51262 if (obj2) {
51263 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51264 if (!SWIG_IsOK(res3)) {
51265 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51266 }
51267 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51268 }
51269 {
51270 PyThreadState* __tstate = wxPyBeginAllowThreads();
51271 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51272 wxPyEndAllowThreads(__tstate);
51273 if (PyErr_Occurred()) SWIG_fail;
51274 }
51275 {
51276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51277 }
51278 return resultobj;
51279 fail:
51280 return NULL;
51281 }
51282
51283
51284 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51285 PyObject *resultobj = 0;
51286 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51287 wxGBPosition *arg2 = 0 ;
51288 wxGBSpan *arg3 = 0 ;
51289 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51290 bool result;
51291 void *argp1 = 0 ;
51292 int res1 = 0 ;
51293 wxGBPosition temp2 ;
51294 wxGBSpan temp3 ;
51295 void *argp4 = 0 ;
51296 int res4 = 0 ;
51297 PyObject * obj0 = 0 ;
51298 PyObject * obj1 = 0 ;
51299 PyObject * obj2 = 0 ;
51300 PyObject * obj3 = 0 ;
51301 char * kwnames[] = {
51302 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51303 };
51304
51305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51307 if (!SWIG_IsOK(res1)) {
51308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51309 }
51310 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51311 {
51312 arg2 = &temp2;
51313 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51314 }
51315 {
51316 arg3 = &temp3;
51317 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51318 }
51319 if (obj3) {
51320 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51321 if (!SWIG_IsOK(res4)) {
51322 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51323 }
51324 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51325 }
51326 {
51327 PyThreadState* __tstate = wxPyBeginAllowThreads();
51328 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51329 wxPyEndAllowThreads(__tstate);
51330 if (PyErr_Occurred()) SWIG_fail;
51331 }
51332 {
51333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51334 }
51335 return resultobj;
51336 fail:
51337 return NULL;
51338 }
51339
51340
51341 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51342 PyObject *obj;
51343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51344 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51345 return SWIG_Py_Void();
51346 }
51347
51348 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51349 return SWIG_Python_InitShadowInstance(args);
51350 }
51351
51352 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51353 PyObject *resultobj = 0;
51354 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51355 wxRelationship arg2 ;
51356 wxWindow *arg3 = (wxWindow *) 0 ;
51357 wxEdge arg4 ;
51358 int arg5 = (int) 0 ;
51359 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51360 void *argp1 = 0 ;
51361 int res1 = 0 ;
51362 int val2 ;
51363 int ecode2 = 0 ;
51364 void *argp3 = 0 ;
51365 int res3 = 0 ;
51366 int val4 ;
51367 int ecode4 = 0 ;
51368 int val5 ;
51369 int ecode5 = 0 ;
51370 int val6 ;
51371 int ecode6 = 0 ;
51372 PyObject * obj0 = 0 ;
51373 PyObject * obj1 = 0 ;
51374 PyObject * obj2 = 0 ;
51375 PyObject * obj3 = 0 ;
51376 PyObject * obj4 = 0 ;
51377 PyObject * obj5 = 0 ;
51378 char * kwnames[] = {
51379 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51380 };
51381
51382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51384 if (!SWIG_IsOK(res1)) {
51385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51386 }
51387 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51388 ecode2 = SWIG_AsVal_int(obj1, &val2);
51389 if (!SWIG_IsOK(ecode2)) {
51390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51391 }
51392 arg2 = static_cast< wxRelationship >(val2);
51393 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51394 if (!SWIG_IsOK(res3)) {
51395 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51396 }
51397 arg3 = reinterpret_cast< wxWindow * >(argp3);
51398 ecode4 = SWIG_AsVal_int(obj3, &val4);
51399 if (!SWIG_IsOK(ecode4)) {
51400 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51401 }
51402 arg4 = static_cast< wxEdge >(val4);
51403 if (obj4) {
51404 ecode5 = SWIG_AsVal_int(obj4, &val5);
51405 if (!SWIG_IsOK(ecode5)) {
51406 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51407 }
51408 arg5 = static_cast< int >(val5);
51409 }
51410 if (obj5) {
51411 ecode6 = SWIG_AsVal_int(obj5, &val6);
51412 if (!SWIG_IsOK(ecode6)) {
51413 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51414 }
51415 arg6 = static_cast< int >(val6);
51416 }
51417 {
51418 PyThreadState* __tstate = wxPyBeginAllowThreads();
51419 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51420 wxPyEndAllowThreads(__tstate);
51421 if (PyErr_Occurred()) SWIG_fail;
51422 }
51423 resultobj = SWIG_Py_Void();
51424 return resultobj;
51425 fail:
51426 return NULL;
51427 }
51428
51429
51430 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51431 PyObject *resultobj = 0;
51432 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51433 wxWindow *arg2 = (wxWindow *) 0 ;
51434 int arg3 = (int) 0 ;
51435 void *argp1 = 0 ;
51436 int res1 = 0 ;
51437 void *argp2 = 0 ;
51438 int res2 = 0 ;
51439 int val3 ;
51440 int ecode3 = 0 ;
51441 PyObject * obj0 = 0 ;
51442 PyObject * obj1 = 0 ;
51443 PyObject * obj2 = 0 ;
51444 char * kwnames[] = {
51445 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51446 };
51447
51448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51450 if (!SWIG_IsOK(res1)) {
51451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51452 }
51453 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51454 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51455 if (!SWIG_IsOK(res2)) {
51456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51457 }
51458 arg2 = reinterpret_cast< wxWindow * >(argp2);
51459 if (obj2) {
51460 ecode3 = SWIG_AsVal_int(obj2, &val3);
51461 if (!SWIG_IsOK(ecode3)) {
51462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51463 }
51464 arg3 = static_cast< int >(val3);
51465 }
51466 {
51467 PyThreadState* __tstate = wxPyBeginAllowThreads();
51468 (arg1)->LeftOf(arg2,arg3);
51469 wxPyEndAllowThreads(__tstate);
51470 if (PyErr_Occurred()) SWIG_fail;
51471 }
51472 resultobj = SWIG_Py_Void();
51473 return resultobj;
51474 fail:
51475 return NULL;
51476 }
51477
51478
51479 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51480 PyObject *resultobj = 0;
51481 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51482 wxWindow *arg2 = (wxWindow *) 0 ;
51483 int arg3 = (int) 0 ;
51484 void *argp1 = 0 ;
51485 int res1 = 0 ;
51486 void *argp2 = 0 ;
51487 int res2 = 0 ;
51488 int val3 ;
51489 int ecode3 = 0 ;
51490 PyObject * obj0 = 0 ;
51491 PyObject * obj1 = 0 ;
51492 PyObject * obj2 = 0 ;
51493 char * kwnames[] = {
51494 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51495 };
51496
51497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51499 if (!SWIG_IsOK(res1)) {
51500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51501 }
51502 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51503 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51504 if (!SWIG_IsOK(res2)) {
51505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51506 }
51507 arg2 = reinterpret_cast< wxWindow * >(argp2);
51508 if (obj2) {
51509 ecode3 = SWIG_AsVal_int(obj2, &val3);
51510 if (!SWIG_IsOK(ecode3)) {
51511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51512 }
51513 arg3 = static_cast< int >(val3);
51514 }
51515 {
51516 PyThreadState* __tstate = wxPyBeginAllowThreads();
51517 (arg1)->RightOf(arg2,arg3);
51518 wxPyEndAllowThreads(__tstate);
51519 if (PyErr_Occurred()) SWIG_fail;
51520 }
51521 resultobj = SWIG_Py_Void();
51522 return resultobj;
51523 fail:
51524 return NULL;
51525 }
51526
51527
51528 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51529 PyObject *resultobj = 0;
51530 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51531 wxWindow *arg2 = (wxWindow *) 0 ;
51532 int arg3 = (int) 0 ;
51533 void *argp1 = 0 ;
51534 int res1 = 0 ;
51535 void *argp2 = 0 ;
51536 int res2 = 0 ;
51537 int val3 ;
51538 int ecode3 = 0 ;
51539 PyObject * obj0 = 0 ;
51540 PyObject * obj1 = 0 ;
51541 PyObject * obj2 = 0 ;
51542 char * kwnames[] = {
51543 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51544 };
51545
51546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51548 if (!SWIG_IsOK(res1)) {
51549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51550 }
51551 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51552 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51553 if (!SWIG_IsOK(res2)) {
51554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51555 }
51556 arg2 = reinterpret_cast< wxWindow * >(argp2);
51557 if (obj2) {
51558 ecode3 = SWIG_AsVal_int(obj2, &val3);
51559 if (!SWIG_IsOK(ecode3)) {
51560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51561 }
51562 arg3 = static_cast< int >(val3);
51563 }
51564 {
51565 PyThreadState* __tstate = wxPyBeginAllowThreads();
51566 (arg1)->Above(arg2,arg3);
51567 wxPyEndAllowThreads(__tstate);
51568 if (PyErr_Occurred()) SWIG_fail;
51569 }
51570 resultobj = SWIG_Py_Void();
51571 return resultobj;
51572 fail:
51573 return NULL;
51574 }
51575
51576
51577 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51578 PyObject *resultobj = 0;
51579 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51580 wxWindow *arg2 = (wxWindow *) 0 ;
51581 int arg3 = (int) 0 ;
51582 void *argp1 = 0 ;
51583 int res1 = 0 ;
51584 void *argp2 = 0 ;
51585 int res2 = 0 ;
51586 int val3 ;
51587 int ecode3 = 0 ;
51588 PyObject * obj0 = 0 ;
51589 PyObject * obj1 = 0 ;
51590 PyObject * obj2 = 0 ;
51591 char * kwnames[] = {
51592 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51593 };
51594
51595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51597 if (!SWIG_IsOK(res1)) {
51598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51599 }
51600 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51601 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51602 if (!SWIG_IsOK(res2)) {
51603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51604 }
51605 arg2 = reinterpret_cast< wxWindow * >(argp2);
51606 if (obj2) {
51607 ecode3 = SWIG_AsVal_int(obj2, &val3);
51608 if (!SWIG_IsOK(ecode3)) {
51609 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51610 }
51611 arg3 = static_cast< int >(val3);
51612 }
51613 {
51614 PyThreadState* __tstate = wxPyBeginAllowThreads();
51615 (arg1)->Below(arg2,arg3);
51616 wxPyEndAllowThreads(__tstate);
51617 if (PyErr_Occurred()) SWIG_fail;
51618 }
51619 resultobj = SWIG_Py_Void();
51620 return resultobj;
51621 fail:
51622 return NULL;
51623 }
51624
51625
51626 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51627 PyObject *resultobj = 0;
51628 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51629 wxWindow *arg2 = (wxWindow *) 0 ;
51630 wxEdge arg3 ;
51631 int arg4 = (int) 0 ;
51632 void *argp1 = 0 ;
51633 int res1 = 0 ;
51634 void *argp2 = 0 ;
51635 int res2 = 0 ;
51636 int val3 ;
51637 int ecode3 = 0 ;
51638 int val4 ;
51639 int ecode4 = 0 ;
51640 PyObject * obj0 = 0 ;
51641 PyObject * obj1 = 0 ;
51642 PyObject * obj2 = 0 ;
51643 PyObject * obj3 = 0 ;
51644 char * kwnames[] = {
51645 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51646 };
51647
51648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51650 if (!SWIG_IsOK(res1)) {
51651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51652 }
51653 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51654 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51655 if (!SWIG_IsOK(res2)) {
51656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51657 }
51658 arg2 = reinterpret_cast< wxWindow * >(argp2);
51659 ecode3 = SWIG_AsVal_int(obj2, &val3);
51660 if (!SWIG_IsOK(ecode3)) {
51661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51662 }
51663 arg3 = static_cast< wxEdge >(val3);
51664 if (obj3) {
51665 ecode4 = SWIG_AsVal_int(obj3, &val4);
51666 if (!SWIG_IsOK(ecode4)) {
51667 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51668 }
51669 arg4 = static_cast< int >(val4);
51670 }
51671 {
51672 PyThreadState* __tstate = wxPyBeginAllowThreads();
51673 (arg1)->SameAs(arg2,arg3,arg4);
51674 wxPyEndAllowThreads(__tstate);
51675 if (PyErr_Occurred()) SWIG_fail;
51676 }
51677 resultobj = SWIG_Py_Void();
51678 return resultobj;
51679 fail:
51680 return NULL;
51681 }
51682
51683
51684 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51685 PyObject *resultobj = 0;
51686 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51687 wxWindow *arg2 = (wxWindow *) 0 ;
51688 wxEdge arg3 ;
51689 int arg4 ;
51690 void *argp1 = 0 ;
51691 int res1 = 0 ;
51692 void *argp2 = 0 ;
51693 int res2 = 0 ;
51694 int val3 ;
51695 int ecode3 = 0 ;
51696 int val4 ;
51697 int ecode4 = 0 ;
51698 PyObject * obj0 = 0 ;
51699 PyObject * obj1 = 0 ;
51700 PyObject * obj2 = 0 ;
51701 PyObject * obj3 = 0 ;
51702 char * kwnames[] = {
51703 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51704 };
51705
51706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51708 if (!SWIG_IsOK(res1)) {
51709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51710 }
51711 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51712 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51713 if (!SWIG_IsOK(res2)) {
51714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51715 }
51716 arg2 = reinterpret_cast< wxWindow * >(argp2);
51717 ecode3 = SWIG_AsVal_int(obj2, &val3);
51718 if (!SWIG_IsOK(ecode3)) {
51719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51720 }
51721 arg3 = static_cast< wxEdge >(val3);
51722 ecode4 = SWIG_AsVal_int(obj3, &val4);
51723 if (!SWIG_IsOK(ecode4)) {
51724 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51725 }
51726 arg4 = static_cast< int >(val4);
51727 {
51728 PyThreadState* __tstate = wxPyBeginAllowThreads();
51729 (arg1)->PercentOf(arg2,arg3,arg4);
51730 wxPyEndAllowThreads(__tstate);
51731 if (PyErr_Occurred()) SWIG_fail;
51732 }
51733 resultobj = SWIG_Py_Void();
51734 return resultobj;
51735 fail:
51736 return NULL;
51737 }
51738
51739
51740 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51741 PyObject *resultobj = 0;
51742 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51743 int arg2 ;
51744 void *argp1 = 0 ;
51745 int res1 = 0 ;
51746 int val2 ;
51747 int ecode2 = 0 ;
51748 PyObject * obj0 = 0 ;
51749 PyObject * obj1 = 0 ;
51750 char * kwnames[] = {
51751 (char *) "self",(char *) "val", NULL
51752 };
51753
51754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51756 if (!SWIG_IsOK(res1)) {
51757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51758 }
51759 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51760 ecode2 = SWIG_AsVal_int(obj1, &val2);
51761 if (!SWIG_IsOK(ecode2)) {
51762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51763 }
51764 arg2 = static_cast< int >(val2);
51765 {
51766 PyThreadState* __tstate = wxPyBeginAllowThreads();
51767 (arg1)->Absolute(arg2);
51768 wxPyEndAllowThreads(__tstate);
51769 if (PyErr_Occurred()) SWIG_fail;
51770 }
51771 resultobj = SWIG_Py_Void();
51772 return resultobj;
51773 fail:
51774 return NULL;
51775 }
51776
51777
51778 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51779 PyObject *resultobj = 0;
51780 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51781 void *argp1 = 0 ;
51782 int res1 = 0 ;
51783 PyObject *swig_obj[1] ;
51784
51785 if (!args) SWIG_fail;
51786 swig_obj[0] = args;
51787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51788 if (!SWIG_IsOK(res1)) {
51789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51790 }
51791 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51792 {
51793 PyThreadState* __tstate = wxPyBeginAllowThreads();
51794 (arg1)->Unconstrained();
51795 wxPyEndAllowThreads(__tstate);
51796 if (PyErr_Occurred()) SWIG_fail;
51797 }
51798 resultobj = SWIG_Py_Void();
51799 return resultobj;
51800 fail:
51801 return NULL;
51802 }
51803
51804
51805 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51806 PyObject *resultobj = 0;
51807 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51808 void *argp1 = 0 ;
51809 int res1 = 0 ;
51810 PyObject *swig_obj[1] ;
51811
51812 if (!args) SWIG_fail;
51813 swig_obj[0] = args;
51814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51815 if (!SWIG_IsOK(res1)) {
51816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51817 }
51818 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51819 {
51820 PyThreadState* __tstate = wxPyBeginAllowThreads();
51821 (arg1)->AsIs();
51822 wxPyEndAllowThreads(__tstate);
51823 if (PyErr_Occurred()) SWIG_fail;
51824 }
51825 resultobj = SWIG_Py_Void();
51826 return resultobj;
51827 fail:
51828 return NULL;
51829 }
51830
51831
51832 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51833 PyObject *resultobj = 0;
51834 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51835 wxWindow *result = 0 ;
51836 void *argp1 = 0 ;
51837 int res1 = 0 ;
51838 PyObject *swig_obj[1] ;
51839
51840 if (!args) SWIG_fail;
51841 swig_obj[0] = args;
51842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51843 if (!SWIG_IsOK(res1)) {
51844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51845 }
51846 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51847 {
51848 PyThreadState* __tstate = wxPyBeginAllowThreads();
51849 result = (wxWindow *)(arg1)->GetOtherWindow();
51850 wxPyEndAllowThreads(__tstate);
51851 if (PyErr_Occurred()) SWIG_fail;
51852 }
51853 {
51854 resultobj = wxPyMake_wxObject(result, 0);
51855 }
51856 return resultobj;
51857 fail:
51858 return NULL;
51859 }
51860
51861
51862 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51863 PyObject *resultobj = 0;
51864 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51865 wxEdge result;
51866 void *argp1 = 0 ;
51867 int res1 = 0 ;
51868 PyObject *swig_obj[1] ;
51869
51870 if (!args) SWIG_fail;
51871 swig_obj[0] = args;
51872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51873 if (!SWIG_IsOK(res1)) {
51874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51875 }
51876 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51877 {
51878 PyThreadState* __tstate = wxPyBeginAllowThreads();
51879 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51880 wxPyEndAllowThreads(__tstate);
51881 if (PyErr_Occurred()) SWIG_fail;
51882 }
51883 resultobj = SWIG_From_int(static_cast< int >(result));
51884 return resultobj;
51885 fail:
51886 return NULL;
51887 }
51888
51889
51890 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51891 PyObject *resultobj = 0;
51892 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51893 wxEdge arg2 ;
51894 void *argp1 = 0 ;
51895 int res1 = 0 ;
51896 int val2 ;
51897 int ecode2 = 0 ;
51898 PyObject * obj0 = 0 ;
51899 PyObject * obj1 = 0 ;
51900 char * kwnames[] = {
51901 (char *) "self",(char *) "which", NULL
51902 };
51903
51904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51906 if (!SWIG_IsOK(res1)) {
51907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51908 }
51909 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51910 ecode2 = SWIG_AsVal_int(obj1, &val2);
51911 if (!SWIG_IsOK(ecode2)) {
51912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51913 }
51914 arg2 = static_cast< wxEdge >(val2);
51915 {
51916 PyThreadState* __tstate = wxPyBeginAllowThreads();
51917 (arg1)->SetEdge(arg2);
51918 wxPyEndAllowThreads(__tstate);
51919 if (PyErr_Occurred()) SWIG_fail;
51920 }
51921 resultobj = SWIG_Py_Void();
51922 return resultobj;
51923 fail:
51924 return NULL;
51925 }
51926
51927
51928 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51929 PyObject *resultobj = 0;
51930 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51931 int arg2 ;
51932 void *argp1 = 0 ;
51933 int res1 = 0 ;
51934 int val2 ;
51935 int ecode2 = 0 ;
51936 PyObject * obj0 = 0 ;
51937 PyObject * obj1 = 0 ;
51938 char * kwnames[] = {
51939 (char *) "self",(char *) "v", NULL
51940 };
51941
51942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51944 if (!SWIG_IsOK(res1)) {
51945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51946 }
51947 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51948 ecode2 = SWIG_AsVal_int(obj1, &val2);
51949 if (!SWIG_IsOK(ecode2)) {
51950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51951 }
51952 arg2 = static_cast< int >(val2);
51953 {
51954 PyThreadState* __tstate = wxPyBeginAllowThreads();
51955 (arg1)->SetValue(arg2);
51956 wxPyEndAllowThreads(__tstate);
51957 if (PyErr_Occurred()) SWIG_fail;
51958 }
51959 resultobj = SWIG_Py_Void();
51960 return resultobj;
51961 fail:
51962 return NULL;
51963 }
51964
51965
51966 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51967 PyObject *resultobj = 0;
51968 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51969 int result;
51970 void *argp1 = 0 ;
51971 int res1 = 0 ;
51972 PyObject *swig_obj[1] ;
51973
51974 if (!args) SWIG_fail;
51975 swig_obj[0] = args;
51976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51977 if (!SWIG_IsOK(res1)) {
51978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51979 }
51980 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51981 {
51982 PyThreadState* __tstate = wxPyBeginAllowThreads();
51983 result = (int)(arg1)->GetMargin();
51984 wxPyEndAllowThreads(__tstate);
51985 if (PyErr_Occurred()) SWIG_fail;
51986 }
51987 resultobj = SWIG_From_int(static_cast< int >(result));
51988 return resultobj;
51989 fail:
51990 return NULL;
51991 }
51992
51993
51994 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51995 PyObject *resultobj = 0;
51996 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51997 int arg2 ;
51998 void *argp1 = 0 ;
51999 int res1 = 0 ;
52000 int val2 ;
52001 int ecode2 = 0 ;
52002 PyObject * obj0 = 0 ;
52003 PyObject * obj1 = 0 ;
52004 char * kwnames[] = {
52005 (char *) "self",(char *) "m", NULL
52006 };
52007
52008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52010 if (!SWIG_IsOK(res1)) {
52011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52012 }
52013 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52014 ecode2 = SWIG_AsVal_int(obj1, &val2);
52015 if (!SWIG_IsOK(ecode2)) {
52016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52017 }
52018 arg2 = static_cast< int >(val2);
52019 {
52020 PyThreadState* __tstate = wxPyBeginAllowThreads();
52021 (arg1)->SetMargin(arg2);
52022 wxPyEndAllowThreads(__tstate);
52023 if (PyErr_Occurred()) SWIG_fail;
52024 }
52025 resultobj = SWIG_Py_Void();
52026 return resultobj;
52027 fail:
52028 return NULL;
52029 }
52030
52031
52032 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52033 PyObject *resultobj = 0;
52034 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52035 int result;
52036 void *argp1 = 0 ;
52037 int res1 = 0 ;
52038 PyObject *swig_obj[1] ;
52039
52040 if (!args) SWIG_fail;
52041 swig_obj[0] = args;
52042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52043 if (!SWIG_IsOK(res1)) {
52044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52045 }
52046 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52047 {
52048 PyThreadState* __tstate = wxPyBeginAllowThreads();
52049 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52050 wxPyEndAllowThreads(__tstate);
52051 if (PyErr_Occurred()) SWIG_fail;
52052 }
52053 resultobj = SWIG_From_int(static_cast< int >(result));
52054 return resultobj;
52055 fail:
52056 return NULL;
52057 }
52058
52059
52060 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52061 PyObject *resultobj = 0;
52062 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52063 int result;
52064 void *argp1 = 0 ;
52065 int res1 = 0 ;
52066 PyObject *swig_obj[1] ;
52067
52068 if (!args) SWIG_fail;
52069 swig_obj[0] = args;
52070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52071 if (!SWIG_IsOK(res1)) {
52072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52073 }
52074 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52075 {
52076 PyThreadState* __tstate = wxPyBeginAllowThreads();
52077 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52078 wxPyEndAllowThreads(__tstate);
52079 if (PyErr_Occurred()) SWIG_fail;
52080 }
52081 resultobj = SWIG_From_int(static_cast< int >(result));
52082 return resultobj;
52083 fail:
52084 return NULL;
52085 }
52086
52087
52088 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52089 PyObject *resultobj = 0;
52090 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52091 int result;
52092 void *argp1 = 0 ;
52093 int res1 = 0 ;
52094 PyObject *swig_obj[1] ;
52095
52096 if (!args) SWIG_fail;
52097 swig_obj[0] = args;
52098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52099 if (!SWIG_IsOK(res1)) {
52100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52101 }
52102 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52103 {
52104 PyThreadState* __tstate = wxPyBeginAllowThreads();
52105 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52106 wxPyEndAllowThreads(__tstate);
52107 if (PyErr_Occurred()) SWIG_fail;
52108 }
52109 resultobj = SWIG_From_int(static_cast< int >(result));
52110 return resultobj;
52111 fail:
52112 return NULL;
52113 }
52114
52115
52116 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52117 PyObject *resultobj = 0;
52118 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52119 bool result;
52120 void *argp1 = 0 ;
52121 int res1 = 0 ;
52122 PyObject *swig_obj[1] ;
52123
52124 if (!args) SWIG_fail;
52125 swig_obj[0] = args;
52126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52127 if (!SWIG_IsOK(res1)) {
52128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52129 }
52130 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52131 {
52132 PyThreadState* __tstate = wxPyBeginAllowThreads();
52133 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52134 wxPyEndAllowThreads(__tstate);
52135 if (PyErr_Occurred()) SWIG_fail;
52136 }
52137 {
52138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52139 }
52140 return resultobj;
52141 fail:
52142 return NULL;
52143 }
52144
52145
52146 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52147 PyObject *resultobj = 0;
52148 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52149 bool arg2 ;
52150 void *argp1 = 0 ;
52151 int res1 = 0 ;
52152 bool val2 ;
52153 int ecode2 = 0 ;
52154 PyObject * obj0 = 0 ;
52155 PyObject * obj1 = 0 ;
52156 char * kwnames[] = {
52157 (char *) "self",(char *) "d", NULL
52158 };
52159
52160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52162 if (!SWIG_IsOK(res1)) {
52163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52164 }
52165 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52166 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52167 if (!SWIG_IsOK(ecode2)) {
52168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52169 }
52170 arg2 = static_cast< bool >(val2);
52171 {
52172 PyThreadState* __tstate = wxPyBeginAllowThreads();
52173 (arg1)->SetDone(arg2);
52174 wxPyEndAllowThreads(__tstate);
52175 if (PyErr_Occurred()) SWIG_fail;
52176 }
52177 resultobj = SWIG_Py_Void();
52178 return resultobj;
52179 fail:
52180 return NULL;
52181 }
52182
52183
52184 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52185 PyObject *resultobj = 0;
52186 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52187 wxRelationship result;
52188 void *argp1 = 0 ;
52189 int res1 = 0 ;
52190 PyObject *swig_obj[1] ;
52191
52192 if (!args) SWIG_fail;
52193 swig_obj[0] = args;
52194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52195 if (!SWIG_IsOK(res1)) {
52196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52197 }
52198 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52199 {
52200 PyThreadState* __tstate = wxPyBeginAllowThreads();
52201 result = (wxRelationship)(arg1)->GetRelationship();
52202 wxPyEndAllowThreads(__tstate);
52203 if (PyErr_Occurred()) SWIG_fail;
52204 }
52205 resultobj = SWIG_From_int(static_cast< int >(result));
52206 return resultobj;
52207 fail:
52208 return NULL;
52209 }
52210
52211
52212 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52213 PyObject *resultobj = 0;
52214 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52215 wxRelationship arg2 ;
52216 void *argp1 = 0 ;
52217 int res1 = 0 ;
52218 int val2 ;
52219 int ecode2 = 0 ;
52220 PyObject * obj0 = 0 ;
52221 PyObject * obj1 = 0 ;
52222 char * kwnames[] = {
52223 (char *) "self",(char *) "r", NULL
52224 };
52225
52226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52228 if (!SWIG_IsOK(res1)) {
52229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52230 }
52231 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52232 ecode2 = SWIG_AsVal_int(obj1, &val2);
52233 if (!SWIG_IsOK(ecode2)) {
52234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52235 }
52236 arg2 = static_cast< wxRelationship >(val2);
52237 {
52238 PyThreadState* __tstate = wxPyBeginAllowThreads();
52239 (arg1)->SetRelationship(arg2);
52240 wxPyEndAllowThreads(__tstate);
52241 if (PyErr_Occurred()) SWIG_fail;
52242 }
52243 resultobj = SWIG_Py_Void();
52244 return resultobj;
52245 fail:
52246 return NULL;
52247 }
52248
52249
52250 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52251 PyObject *resultobj = 0;
52252 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52253 wxWindow *arg2 = (wxWindow *) 0 ;
52254 bool result;
52255 void *argp1 = 0 ;
52256 int res1 = 0 ;
52257 void *argp2 = 0 ;
52258 int res2 = 0 ;
52259 PyObject * obj0 = 0 ;
52260 PyObject * obj1 = 0 ;
52261 char * kwnames[] = {
52262 (char *) "self",(char *) "otherW", NULL
52263 };
52264
52265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52267 if (!SWIG_IsOK(res1)) {
52268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52269 }
52270 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52272 if (!SWIG_IsOK(res2)) {
52273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52274 }
52275 arg2 = reinterpret_cast< wxWindow * >(argp2);
52276 {
52277 PyThreadState* __tstate = wxPyBeginAllowThreads();
52278 result = (bool)(arg1)->ResetIfWin(arg2);
52279 wxPyEndAllowThreads(__tstate);
52280 if (PyErr_Occurred()) SWIG_fail;
52281 }
52282 {
52283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52284 }
52285 return resultobj;
52286 fail:
52287 return NULL;
52288 }
52289
52290
52291 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52292 PyObject *resultobj = 0;
52293 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52294 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52295 wxWindow *arg3 = (wxWindow *) 0 ;
52296 bool result;
52297 void *argp1 = 0 ;
52298 int res1 = 0 ;
52299 void *argp2 = 0 ;
52300 int res2 = 0 ;
52301 void *argp3 = 0 ;
52302 int res3 = 0 ;
52303 PyObject * obj0 = 0 ;
52304 PyObject * obj1 = 0 ;
52305 PyObject * obj2 = 0 ;
52306 char * kwnames[] = {
52307 (char *) "self",(char *) "constraints",(char *) "win", NULL
52308 };
52309
52310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52312 if (!SWIG_IsOK(res1)) {
52313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52314 }
52315 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52316 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52317 if (!SWIG_IsOK(res2)) {
52318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52319 }
52320 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52321 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52322 if (!SWIG_IsOK(res3)) {
52323 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52324 }
52325 arg3 = reinterpret_cast< wxWindow * >(argp3);
52326 {
52327 PyThreadState* __tstate = wxPyBeginAllowThreads();
52328 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52329 wxPyEndAllowThreads(__tstate);
52330 if (PyErr_Occurred()) SWIG_fail;
52331 }
52332 {
52333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52334 }
52335 return resultobj;
52336 fail:
52337 return NULL;
52338 }
52339
52340
52341 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52342 PyObject *resultobj = 0;
52343 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52344 wxEdge arg2 ;
52345 wxWindow *arg3 = (wxWindow *) 0 ;
52346 wxWindow *arg4 = (wxWindow *) 0 ;
52347 int result;
52348 void *argp1 = 0 ;
52349 int res1 = 0 ;
52350 int val2 ;
52351 int ecode2 = 0 ;
52352 void *argp3 = 0 ;
52353 int res3 = 0 ;
52354 void *argp4 = 0 ;
52355 int res4 = 0 ;
52356 PyObject * obj0 = 0 ;
52357 PyObject * obj1 = 0 ;
52358 PyObject * obj2 = 0 ;
52359 PyObject * obj3 = 0 ;
52360 char * kwnames[] = {
52361 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52362 };
52363
52364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52366 if (!SWIG_IsOK(res1)) {
52367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52368 }
52369 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52370 ecode2 = SWIG_AsVal_int(obj1, &val2);
52371 if (!SWIG_IsOK(ecode2)) {
52372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52373 }
52374 arg2 = static_cast< wxEdge >(val2);
52375 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52376 if (!SWIG_IsOK(res3)) {
52377 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52378 }
52379 arg3 = reinterpret_cast< wxWindow * >(argp3);
52380 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52381 if (!SWIG_IsOK(res4)) {
52382 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52383 }
52384 arg4 = reinterpret_cast< wxWindow * >(argp4);
52385 {
52386 PyThreadState* __tstate = wxPyBeginAllowThreads();
52387 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52388 wxPyEndAllowThreads(__tstate);
52389 if (PyErr_Occurred()) SWIG_fail;
52390 }
52391 resultobj = SWIG_From_int(static_cast< int >(result));
52392 return resultobj;
52393 fail:
52394 return NULL;
52395 }
52396
52397
52398 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52399 PyObject *obj;
52400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52401 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52402 return SWIG_Py_Void();
52403 }
52404
52405 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52406 PyObject *resultobj = 0;
52407 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52408 wxIndividualLayoutConstraint *result = 0 ;
52409 void *argp1 = 0 ;
52410 int res1 = 0 ;
52411 PyObject *swig_obj[1] ;
52412
52413 if (!args) SWIG_fail;
52414 swig_obj[0] = args;
52415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52416 if (!SWIG_IsOK(res1)) {
52417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52418 }
52419 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52420 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52422 return resultobj;
52423 fail:
52424 return NULL;
52425 }
52426
52427
52428 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52429 PyObject *resultobj = 0;
52430 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52431 wxIndividualLayoutConstraint *result = 0 ;
52432 void *argp1 = 0 ;
52433 int res1 = 0 ;
52434 PyObject *swig_obj[1] ;
52435
52436 if (!args) SWIG_fail;
52437 swig_obj[0] = args;
52438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52439 if (!SWIG_IsOK(res1)) {
52440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52441 }
52442 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52443 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52445 return resultobj;
52446 fail:
52447 return NULL;
52448 }
52449
52450
52451 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52452 PyObject *resultobj = 0;
52453 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52454 wxIndividualLayoutConstraint *result = 0 ;
52455 void *argp1 = 0 ;
52456 int res1 = 0 ;
52457 PyObject *swig_obj[1] ;
52458
52459 if (!args) SWIG_fail;
52460 swig_obj[0] = args;
52461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52462 if (!SWIG_IsOK(res1)) {
52463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52464 }
52465 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52466 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52468 return resultobj;
52469 fail:
52470 return NULL;
52471 }
52472
52473
52474 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52475 PyObject *resultobj = 0;
52476 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52477 wxIndividualLayoutConstraint *result = 0 ;
52478 void *argp1 = 0 ;
52479 int res1 = 0 ;
52480 PyObject *swig_obj[1] ;
52481
52482 if (!args) SWIG_fail;
52483 swig_obj[0] = args;
52484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52485 if (!SWIG_IsOK(res1)) {
52486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52487 }
52488 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52489 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52491 return resultobj;
52492 fail:
52493 return NULL;
52494 }
52495
52496
52497 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52498 PyObject *resultobj = 0;
52499 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52500 wxIndividualLayoutConstraint *result = 0 ;
52501 void *argp1 = 0 ;
52502 int res1 = 0 ;
52503 PyObject *swig_obj[1] ;
52504
52505 if (!args) SWIG_fail;
52506 swig_obj[0] = args;
52507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52508 if (!SWIG_IsOK(res1)) {
52509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52510 }
52511 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52512 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52514 return resultobj;
52515 fail:
52516 return NULL;
52517 }
52518
52519
52520 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52521 PyObject *resultobj = 0;
52522 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52523 wxIndividualLayoutConstraint *result = 0 ;
52524 void *argp1 = 0 ;
52525 int res1 = 0 ;
52526 PyObject *swig_obj[1] ;
52527
52528 if (!args) SWIG_fail;
52529 swig_obj[0] = args;
52530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52531 if (!SWIG_IsOK(res1)) {
52532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52533 }
52534 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52535 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52537 return resultobj;
52538 fail:
52539 return NULL;
52540 }
52541
52542
52543 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52544 PyObject *resultobj = 0;
52545 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52546 wxIndividualLayoutConstraint *result = 0 ;
52547 void *argp1 = 0 ;
52548 int res1 = 0 ;
52549 PyObject *swig_obj[1] ;
52550
52551 if (!args) SWIG_fail;
52552 swig_obj[0] = args;
52553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52554 if (!SWIG_IsOK(res1)) {
52555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52556 }
52557 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52558 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52560 return resultobj;
52561 fail:
52562 return NULL;
52563 }
52564
52565
52566 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52567 PyObject *resultobj = 0;
52568 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52569 wxIndividualLayoutConstraint *result = 0 ;
52570 void *argp1 = 0 ;
52571 int res1 = 0 ;
52572 PyObject *swig_obj[1] ;
52573
52574 if (!args) SWIG_fail;
52575 swig_obj[0] = args;
52576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52577 if (!SWIG_IsOK(res1)) {
52578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52579 }
52580 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52581 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52583 return resultobj;
52584 fail:
52585 return NULL;
52586 }
52587
52588
52589 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52590 PyObject *resultobj = 0;
52591 wxLayoutConstraints *result = 0 ;
52592
52593 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52594 {
52595 PyThreadState* __tstate = wxPyBeginAllowThreads();
52596 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52597 wxPyEndAllowThreads(__tstate);
52598 if (PyErr_Occurred()) SWIG_fail;
52599 }
52600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52601 return resultobj;
52602 fail:
52603 return NULL;
52604 }
52605
52606
52607 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52608 PyObject *resultobj = 0;
52609 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52610 void *argp1 = 0 ;
52611 int res1 = 0 ;
52612 PyObject *swig_obj[1] ;
52613
52614 if (!args) SWIG_fail;
52615 swig_obj[0] = args;
52616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52617 if (!SWIG_IsOK(res1)) {
52618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52619 }
52620 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52621 {
52622 PyThreadState* __tstate = wxPyBeginAllowThreads();
52623 delete arg1;
52624
52625 wxPyEndAllowThreads(__tstate);
52626 if (PyErr_Occurred()) SWIG_fail;
52627 }
52628 resultobj = SWIG_Py_Void();
52629 return resultobj;
52630 fail:
52631 return NULL;
52632 }
52633
52634
52635 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52636 PyObject *resultobj = 0;
52637 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52638 wxWindow *arg2 = (wxWindow *) 0 ;
52639 int *arg3 = (int *) 0 ;
52640 bool result;
52641 void *argp1 = 0 ;
52642 int res1 = 0 ;
52643 void *argp2 = 0 ;
52644 int res2 = 0 ;
52645 int temp3 ;
52646 int res3 = SWIG_TMPOBJ ;
52647 PyObject * obj0 = 0 ;
52648 PyObject * obj1 = 0 ;
52649 char * kwnames[] = {
52650 (char *) "self",(char *) "win", NULL
52651 };
52652
52653 arg3 = &temp3;
52654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52656 if (!SWIG_IsOK(res1)) {
52657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52658 }
52659 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52660 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52661 if (!SWIG_IsOK(res2)) {
52662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52663 }
52664 arg2 = reinterpret_cast< wxWindow * >(argp2);
52665 {
52666 PyThreadState* __tstate = wxPyBeginAllowThreads();
52667 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52668 wxPyEndAllowThreads(__tstate);
52669 if (PyErr_Occurred()) SWIG_fail;
52670 }
52671 {
52672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52673 }
52674 if (SWIG_IsTmpObj(res3)) {
52675 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52676 } else {
52677 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52678 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52679 }
52680 return resultobj;
52681 fail:
52682 return NULL;
52683 }
52684
52685
52686 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52687 PyObject *resultobj = 0;
52688 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52689 bool result;
52690 void *argp1 = 0 ;
52691 int res1 = 0 ;
52692 PyObject *swig_obj[1] ;
52693
52694 if (!args) SWIG_fail;
52695 swig_obj[0] = args;
52696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52697 if (!SWIG_IsOK(res1)) {
52698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52699 }
52700 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52701 {
52702 PyThreadState* __tstate = wxPyBeginAllowThreads();
52703 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52704 wxPyEndAllowThreads(__tstate);
52705 if (PyErr_Occurred()) SWIG_fail;
52706 }
52707 {
52708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52709 }
52710 return resultobj;
52711 fail:
52712 return NULL;
52713 }
52714
52715
52716 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52717 PyObject *obj;
52718 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52719 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52720 return SWIG_Py_Void();
52721 }
52722
52723 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52724 return SWIG_Python_InitShadowInstance(args);
52725 }
52726
52727 static PyMethodDef SwigMethods[] = {
52728 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52729 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52730 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52731 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52732 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52733 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52734 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52735 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52736 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52737 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52738 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52739 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52741 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52746 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52747 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52748 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52749 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52750 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52751 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52752 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52753 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52754 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52755 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52756 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52757 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52758 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52760 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52763 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52765 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52766 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52767 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52768 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52769 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52770 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52771 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52772 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52773 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52774 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52776 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52777 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52778 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52779 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52782 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52783 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52784 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52785 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52789 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52790 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52792 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52794 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52796 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52798 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52800 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52802 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52803 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52804 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52805 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52807 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52808 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52809 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52810 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52823 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52826 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52827 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52828 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52829 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52830 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52831 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52832 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52833 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52834 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52835 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52836 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52838 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52839 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52840 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52845 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52846 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52847 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52848 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52851 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52855 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52858 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52862 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52863 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52864 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52865 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52867 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52868 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52869 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52871 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52872 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52873 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52874 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52877 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52879 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52880 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52881 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52882 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52883 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52884 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52887 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52888 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52889 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52890 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52891 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52892 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52893 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52894 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52895 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52896 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52897 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52898 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52899 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52900 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52901 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52902 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52903 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52904 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52909 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52910 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52915 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52916 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52917 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52918 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52919 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52920 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52923 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52925 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52928 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52929 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52930 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52933 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52934 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52935 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52939 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52940 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52941 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52945 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52947 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52950 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52951 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52952 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52953 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52954 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52955 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52956 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52963 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52964 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52966 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52967 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52968 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52970 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52973 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52974 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52975 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52976 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52977 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52978 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52979 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52980 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52981 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52982 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52983 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52984 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52986 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52987 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52988 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52989 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52990 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52991 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52992 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52993 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52995 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52996 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53000 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53003 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53004 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53005 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53009 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53016 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53017 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53018 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53025 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53029 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53030 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53032 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53033 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53034 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53035 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53037 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53038 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53040 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53041 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53042 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53044 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53046 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53049 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53050 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53051 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53052 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53054 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53067 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53071 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53072 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53078 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53079 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53080 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53081 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53082 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53083 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53084 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53085 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53086 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53087 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53088 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53089 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53090 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53091 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53092 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53093 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53094 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53095 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53096 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53097 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53098 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53099 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53100 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53101 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53102 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53103 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53104 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53105 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53106 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53107 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53108 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53109 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53110 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53111 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53112 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53114 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53115 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53116 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53117 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53120 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53124 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53128 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53129 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53130 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53131 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53133 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53134 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53136 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53138 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53140 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53142 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53143 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53144 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53146 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53147 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53149 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53150 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53151 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53153 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53154 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53155 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53157 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53159 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53160 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53161 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53163 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53165 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53166 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53168 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53169 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53170 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53171 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53172 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53173 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53174 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53175 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53176 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53178 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53179 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53182 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53183 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53185 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53186 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53189 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53190 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53192 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53195 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53198 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53199 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53200 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53201 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53202 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53203 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53204 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53205 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53206 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53207 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53208 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53209 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53210 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53211 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53212 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53213 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53214 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53215 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53216 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53217 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53218 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53219 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53220 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53221 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53223 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53224 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53225 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53226 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53227 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53228 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53229 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53230 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53231 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53232 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53233 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53234 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53235 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53236 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53237 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53238 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53239 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53240 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53241 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53242 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53243 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53244 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53245 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53246 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53247 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53248 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53249 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53250 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53251 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53252 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53253 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53254 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53256 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53257 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53259 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53260 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53261 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53262 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53264 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53265 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53266 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53267 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53268 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53269 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53270 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53271 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53272 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53274 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53275 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53276 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53277 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53278 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53279 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53280 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53281 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53282 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53283 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53284 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53285 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53286 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53287 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53288 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53289 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53290 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53291 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53292 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53293 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53294 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53295 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53296 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53297 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53298 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53299 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53300 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53301 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53303 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53304 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53307 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53308 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53309 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53310 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53311 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53312 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53314 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53315 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53318 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53319 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53321 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53322 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53324 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53325 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53327 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53328 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53329 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53331 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53333 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53334 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53336 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53337 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53338 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53339 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53340 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53341 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53342 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53344 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53345 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53347 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53348 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53349 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53350 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53351 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53354 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53356 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53358 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53359 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53360 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53363 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53364 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53365 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53366 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53367 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53368 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53369 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53371 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53372 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53373 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53374 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53375 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53376 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53378 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53379 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53380 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53381 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53382 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53383 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53384 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53385 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53391 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53393 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53395 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53396 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53397 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53398 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53399 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53400 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53402 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53403 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53404 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53405 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53406 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53407 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53410 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53411 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53412 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53415 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53416 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53417 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53418 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53419 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53421 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53423 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53426 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53428 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53429 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53431 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53432 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53433 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53435 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53436 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53437 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53439 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53441 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53442 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53443 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53445 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53447 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53449 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53450 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53452 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53453 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53455 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53457 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53458 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53459 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53461 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53463 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53464 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53465 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53467 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53469 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53470 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53471 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53472 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53474 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53476 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53478 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53480 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53481 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53483 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53484 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53485 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53486 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53487 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53488 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53489 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53490 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53492 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53494 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53496 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53498 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53500 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53502 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53503 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53504 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53505 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53506 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53507 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53513 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53514 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53515 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53516 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53517 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53518 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53519 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53521 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53523 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53524 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53526 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53527 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53528 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53529 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53531 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53532 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53533 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53534 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53536 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53537 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53539 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53540 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53541 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53543 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53545 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53546 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53547 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53548 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53549 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53551 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53552 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53553 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53554 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53556 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53557 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53558 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53559 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53560 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53561 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53562 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53563 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53564 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53565 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53566 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53567 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53570 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53571 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53572 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53574 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53576 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53578 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53580 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53581 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53591 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53592 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53593 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53596 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53597 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53598 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53599 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53600 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53601 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53602 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53603 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53604 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53605 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53606 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53607 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53608 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53609 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53610 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53612 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53613 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53616 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53617 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53619 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53622 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53623 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53626 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53627 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53628 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53629 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53632 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53633 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53634 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53636 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53638 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53639 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53640 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53642 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53644 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53646 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53649 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53650 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53651 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53652 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53653 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53654 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53655 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53661 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53662 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53663 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53664 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53671 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53677 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53678 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53679 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53680 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53681 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53683 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53693 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53694 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53695 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53696 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53699 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53700 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53701 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53702 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53704 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53705 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53709 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53715 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53716 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53717 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53718 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53720 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53721 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53723 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53726 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53728 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53729 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53730 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53739 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53743 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53745 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53755 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53756 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53757 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53758 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53762 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53765 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53767 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53770 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53772 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53773 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53776 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53778 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53779 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53780 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53781 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53782 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53787 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53788 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53789 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53791 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53792 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53793 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53795 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53797 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53798 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53799 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53801 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53802 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53805 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53813 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53820 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53828 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53831 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53832 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53845 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53847 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53849 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53850 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53852 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53854 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53855 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53857 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53858 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53859 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53863 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53882 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53883 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53885 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53887 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53888 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53889 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53891 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53892 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53895 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53896 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53898 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53899 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53901 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53904 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53905 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53907 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53909 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53911 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53912 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53914 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53915 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53918 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53920 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53922 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53924 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53927 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53929 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53930 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53931 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53933 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53934 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53935 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53937 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53940 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53942 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53943 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53947 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53951 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53952 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53954 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53958 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53960 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53962 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53963 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53964 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53965 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53969 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53970 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53971 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53972 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53974 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53975 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53980 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53981 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53982 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53983 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53984 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53986 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53988 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53990 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53991 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53993 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53995 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53998 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53999 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54000 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54002 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54003 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54004 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54018 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54019 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54020 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54021 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54022 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54023 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54029 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54030 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54034 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54035 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54037 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54038 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54040 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54042 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54043 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54045 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54046 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54047 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54053 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54054 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54055 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54056 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54057 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54058 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54065 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54067 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54068 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54069 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54070 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54071 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54072 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54074 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54078 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54079 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54080 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54081 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54082 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54083 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54084 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54086 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54087 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54088 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54094 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54095 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54096 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54098 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54099 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54100 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54106 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54107 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54108 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54109 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54110 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54114 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54115 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54116 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54120 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54121 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54123 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54124 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54125 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54129 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54131 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54132 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54133 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54134 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54135 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54140 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54141 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54150 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54151 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54152 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54153 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54156 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54158 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54159 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54160 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54161 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54163 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54168 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54169 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54170 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54171 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54172 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54173 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54174 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54175 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54176 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54177 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54178 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54180 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54181 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54182 { NULL, NULL, 0, NULL }
54183 };
54184
54185
54186 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54187
54188 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54189 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54190 }
54191 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54192 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54193 }
54194 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54195 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54196 }
54197 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54198 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54199 }
54200 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54201 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54202 }
54203 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54204 return (void *)((wxSizer *) ((wxGridSizer *) x));
54205 }
54206 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54207 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54208 }
54209 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54210 return (void *)((wxSizer *) ((wxPySizer *) x));
54211 }
54212 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54213 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54214 }
54215 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54216 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54217 }
54218 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54219 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54220 }
54221 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54222 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54223 }
54224 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54225 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54226 }
54227 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54228 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54229 }
54230 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54231 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54232 }
54233 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54234 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54235 }
54236 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54237 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54238 }
54239 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54240 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54241 }
54242 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54243 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54244 }
54245 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54246 return (void *)((wxEvent *) ((wxPyEvent *) x));
54247 }
54248 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54249 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54250 }
54251 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54252 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54253 }
54254 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54255 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54256 }
54257 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54258 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54259 }
54260 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54261 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54262 }
54263 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54264 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54265 }
54266 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54267 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54268 }
54269 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54270 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54271 }
54272 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54273 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54274 }
54275 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54276 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54277 }
54278 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54279 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54280 }
54281 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54282 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54283 }
54284 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54285 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54286 }
54287 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54288 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54289 }
54290 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54291 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54292 }
54293 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54294 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54295 }
54296 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54297 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54298 }
54299 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54300 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54301 }
54302 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54303 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54304 }
54305 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54306 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54307 }
54308 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54309 return (void *)((wxEvent *) ((wxShowEvent *) x));
54310 }
54311 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54312 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54313 }
54314 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54315 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54316 }
54317 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54318 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54319 }
54320 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54321 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54322 }
54323 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54324 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54325 }
54326 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54327 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54328 }
54329 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54330 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54331 }
54332 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54333 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54334 }
54335 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54336 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54337 }
54338 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54339 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54340 }
54341 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54342 return (void *)((wxControl *) ((wxControlWithItems *) x));
54343 }
54344 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54345 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54346 }
54347 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54348 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54349 }
54350 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54351 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54352 }
54353 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54354 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54355 }
54356 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54357 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54358 }
54359 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54360 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54361 }
54362 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54363 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54364 }
54365 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54366 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54367 }
54368 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54369 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54370 }
54371 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54372 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54373 }
54374 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54375 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54376 }
54377 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54378 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54379 }
54380 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54381 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54382 }
54383 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54384 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54385 }
54386 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54387 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54388 }
54389 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54390 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54391 }
54392 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54393 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54394 }
54395 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54396 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54397 }
54398 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54399 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54400 }
54401 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54402 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54403 }
54404 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54405 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54406 }
54407 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54408 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54409 }
54410 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54411 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54412 }
54413 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54414 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54415 }
54416 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54417 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54418 }
54419 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54420 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54421 }
54422 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54423 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54424 }
54425 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54426 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54427 }
54428 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54429 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54430 }
54431 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54432 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54433 }
54434 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54435 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54436 }
54437 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54438 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54439 }
54440 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54441 return (void *)((wxObject *) ((wxSizerItem *) x));
54442 }
54443 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54444 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54445 }
54446 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54447 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54448 }
54449 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54450 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54451 }
54452 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54453 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54454 }
54455 static void *_p_wxSizerTo_p_wxObject(void *x) {
54456 return (void *)((wxObject *) ((wxSizer *) x));
54457 }
54458 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54459 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54460 }
54461 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54462 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54463 }
54464 static void *_p_wxEventTo_p_wxObject(void *x) {
54465 return (void *)((wxObject *) ((wxEvent *) x));
54466 }
54467 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54468 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54469 }
54470 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54471 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54472 }
54473 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54474 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54475 }
54476 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54477 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54478 }
54479 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54480 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54481 }
54482 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54483 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54484 }
54485 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54486 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54487 }
54488 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54489 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54490 }
54491 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54492 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54493 }
54494 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54495 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54496 }
54497 static void *_p_wxControlTo_p_wxObject(void *x) {
54498 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54499 }
54500 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54501 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54502 }
54503 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54504 return (void *)((wxObject *) ((wxFSFile *) x));
54505 }
54506 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54507 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54508 }
54509 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54510 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54511 }
54512 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54513 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54514 }
54515 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54516 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54517 }
54518 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54519 return (void *)((wxObject *) ((wxMenuItem *) x));
54520 }
54521 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54522 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54523 }
54524 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54525 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54526 }
54527 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54528 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54529 }
54530 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54531 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54532 }
54533 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54534 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54535 }
54536 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54537 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54538 }
54539 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54540 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54541 }
54542 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54543 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54544 }
54545 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54546 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54547 }
54548 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54549 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54550 }
54551 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54552 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54553 }
54554 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54555 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54556 }
54557 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54558 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54559 }
54560 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54561 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54562 }
54563 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54564 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54565 }
54566 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54567 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54568 }
54569 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54570 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54571 }
54572 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54573 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54574 }
54575 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54576 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54577 }
54578 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54579 return (void *)((wxObject *) ((wxImageHandler *) x));
54580 }
54581 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54582 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54583 }
54584 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54585 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54586 }
54587 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54588 return (void *)((wxObject *) ((wxEvtHandler *) x));
54589 }
54590 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54591 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54592 }
54593 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54594 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54595 }
54596 static void *_p_wxImageTo_p_wxObject(void *x) {
54597 return (void *)((wxObject *) ((wxImage *) x));
54598 }
54599 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54600 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54601 }
54602 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54603 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54604 }
54605 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54606 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54607 }
54608 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54609 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54610 }
54611 static void *_p_wxWindowTo_p_wxObject(void *x) {
54612 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54613 }
54614 static void *_p_wxMenuTo_p_wxObject(void *x) {
54615 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54616 }
54617 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54618 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54619 }
54620 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54621 return (void *)((wxObject *) ((wxFileSystem *) x));
54622 }
54623 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54624 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54625 }
54626 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54627 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54628 }
54629 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54630 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54631 }
54632 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54633 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54634 }
54635 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54636 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54637 }
54638 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54639 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54640 }
54641 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54642 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54643 }
54644 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54645 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54646 }
54647 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54648 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54649 }
54650 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54651 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54652 }
54653 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54654 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54655 }
54656 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54657 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54658 }
54659 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54660 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54661 }
54662 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54663 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54664 }
54665 static void *_p_wxControlTo_p_wxWindow(void *x) {
54666 return (void *)((wxWindow *) ((wxControl *) x));
54667 }
54668 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54669 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54670 }
54671 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54672 return (void *)((wxWindow *) ((wxMenuBar *) x));
54673 }
54674 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54675 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54676 }
54677 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54678 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54679 }
54680 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54681 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54682 }
54683 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54684 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54685 }
54686 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54687 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54688 }
54689 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54690 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54691 }
54692 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54693 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54694 }
54695 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54696 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54697 }
54698 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54699 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54700 }
54701 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54702 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54703 }
54704 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54705 return (void *)((wxValidator *) ((wxPyValidator *) x));
54706 }
54707 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54708 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54709 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};
54710 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54711 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54712 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54713 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54714 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54715 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54716 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54717 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54718 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54719 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54720 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54721 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54722 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54723 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54724 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54725 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54726 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54727 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54728 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54729 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54730 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54731 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54732 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54733 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54734 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54735 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54736 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54737 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54738 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54739 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54740 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54741 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54742 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54743 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54744 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54745 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54746 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54747 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54748 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54749 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54750 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54751 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54752 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54753 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54754 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54755 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54756 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54757 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54758 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54759 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54760 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54761 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54762 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54763 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54764 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54765 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54766 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54767 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54768 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54769 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54770 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54771 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54772 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54773 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54774 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54775 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54776 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54777 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54778 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54779 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54780 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54781 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54782 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54783 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54784 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54785 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54786 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54787 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54788 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54789 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54790 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54791 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54792 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54793 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54794 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54795 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54796 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54797 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54798 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54799 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54800 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54801 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54802 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54803 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54804 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54805 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54806 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54807 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54808 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54809 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54810 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54811 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54812 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54813 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54814 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54815 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54816 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54817 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54818 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54819 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54820 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54821 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54822 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54834 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54835 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54836 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54837 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54838
54839 static swig_type_info *swig_type_initial[] = {
54840 &_swigt__p_buffer,
54841 &_swigt__p_char,
54842 &_swigt__p_form_ops_t,
54843 &_swigt__p_int,
54844 &_swigt__p_long,
54845 &_swigt__p_unsigned_char,
54846 &_swigt__p_unsigned_int,
54847 &_swigt__p_unsigned_long,
54848 &_swigt__p_wxANIHandler,
54849 &_swigt__p_wxAcceleratorEntry,
54850 &_swigt__p_wxAcceleratorTable,
54851 &_swigt__p_wxActivateEvent,
54852 &_swigt__p_wxAppTraits,
54853 &_swigt__p_wxArrayString,
54854 &_swigt__p_wxBMPHandler,
54855 &_swigt__p_wxBitmap,
54856 &_swigt__p_wxBoxSizer,
54857 &_swigt__p_wxButton,
54858 &_swigt__p_wxCURHandler,
54859 &_swigt__p_wxCaret,
54860 &_swigt__p_wxChildFocusEvent,
54861 &_swigt__p_wxClipboardTextEvent,
54862 &_swigt__p_wxCloseEvent,
54863 &_swigt__p_wxColour,
54864 &_swigt__p_wxCommandEvent,
54865 &_swigt__p_wxContextMenuEvent,
54866 &_swigt__p_wxControl,
54867 &_swigt__p_wxControlWithItems,
54868 &_swigt__p_wxCursor,
54869 &_swigt__p_wxDC,
54870 &_swigt__p_wxDateEvent,
54871 &_swigt__p_wxDateTime,
54872 &_swigt__p_wxDisplayChangedEvent,
54873 &_swigt__p_wxDropFilesEvent,
54874 &_swigt__p_wxDuplexMode,
54875 &_swigt__p_wxEraseEvent,
54876 &_swigt__p_wxEvent,
54877 &_swigt__p_wxEventLoop,
54878 &_swigt__p_wxEventLoopActivator,
54879 &_swigt__p_wxEvtHandler,
54880 &_swigt__p_wxFSFile,
54881 &_swigt__p_wxFileSystem,
54882 &_swigt__p_wxFileSystemHandler,
54883 &_swigt__p_wxFlexGridSizer,
54884 &_swigt__p_wxFocusEvent,
54885 &_swigt__p_wxFont,
54886 &_swigt__p_wxFrame,
54887 &_swigt__p_wxGBPosition,
54888 &_swigt__p_wxGBSizerItem,
54889 &_swigt__p_wxGBSpan,
54890 &_swigt__p_wxGIFHandler,
54891 &_swigt__p_wxGridBagSizer,
54892 &_swigt__p_wxGridSizer,
54893 &_swigt__p_wxHelpEvent__Origin,
54894 &_swigt__p_wxICOHandler,
54895 &_swigt__p_wxIconizeEvent,
54896 &_swigt__p_wxIdleEvent,
54897 &_swigt__p_wxImage,
54898 &_swigt__p_wxImageHandler,
54899 &_swigt__p_wxImageHistogram,
54900 &_swigt__p_wxImage_HSVValue,
54901 &_swigt__p_wxImage_RGBValue,
54902 &_swigt__p_wxIndividualLayoutConstraint,
54903 &_swigt__p_wxInitDialogEvent,
54904 &_swigt__p_wxInputStream,
54905 &_swigt__p_wxInternetFSHandler,
54906 &_swigt__p_wxItemContainer,
54907 &_swigt__p_wxJPEGHandler,
54908 &_swigt__p_wxKeyEvent,
54909 &_swigt__p_wxLayoutConstraints,
54910 &_swigt__p_wxMaximizeEvent,
54911 &_swigt__p_wxMemoryFSHandler,
54912 &_swigt__p_wxMenu,
54913 &_swigt__p_wxMenuBar,
54914 &_swigt__p_wxMenuBarBase,
54915 &_swigt__p_wxMenuEvent,
54916 &_swigt__p_wxMenuItem,
54917 &_swigt__p_wxMouseCaptureChangedEvent,
54918 &_swigt__p_wxMouseEvent,
54919 &_swigt__p_wxMoveEvent,
54920 &_swigt__p_wxNavigationKeyEvent,
54921 &_swigt__p_wxNcPaintEvent,
54922 &_swigt__p_wxNotifyEvent,
54923 &_swigt__p_wxObject,
54924 &_swigt__p_wxOutputStream,
54925 &_swigt__p_wxPCXHandler,
54926 &_swigt__p_wxPNGHandler,
54927 &_swigt__p_wxPNMHandler,
54928 &_swigt__p_wxPaintEvent,
54929 &_swigt__p_wxPaletteChangedEvent,
54930 &_swigt__p_wxPaperSize,
54931 &_swigt__p_wxPoint,
54932 &_swigt__p_wxPoint2D,
54933 &_swigt__p_wxPropagateOnce,
54934 &_swigt__p_wxPropagationDisabler,
54935 &_swigt__p_wxPyApp,
54936 &_swigt__p_wxPyCommandEvent,
54937 &_swigt__p_wxPyDropTarget,
54938 &_swigt__p_wxPyEvent,
54939 &_swigt__p_wxPyFileSystemHandler,
54940 &_swigt__p_wxPyImageHandler,
54941 &_swigt__p_wxPyInputStream,
54942 &_swigt__p_wxPySizer,
54943 &_swigt__p_wxPyValidator,
54944 &_swigt__p_wxQuantize,
54945 &_swigt__p_wxQueryNewPaletteEvent,
54946 &_swigt__p_wxRealPoint,
54947 &_swigt__p_wxRect,
54948 &_swigt__p_wxRegion,
54949 &_swigt__p_wxScrollEvent,
54950 &_swigt__p_wxScrollWinEvent,
54951 &_swigt__p_wxSetCursorEvent,
54952 &_swigt__p_wxShowEvent,
54953 &_swigt__p_wxSize,
54954 &_swigt__p_wxSizeEvent,
54955 &_swigt__p_wxSizer,
54956 &_swigt__p_wxSizerItem,
54957 &_swigt__p_wxStaticBox,
54958 &_swigt__p_wxStaticBoxSizer,
54959 &_swigt__p_wxStdDialogButtonSizer,
54960 &_swigt__p_wxSysColourChangedEvent,
54961 &_swigt__p_wxTIFFHandler,
54962 &_swigt__p_wxToolTip,
54963 &_swigt__p_wxUpdateUIEvent,
54964 &_swigt__p_wxValidator,
54965 &_swigt__p_wxVisualAttributes,
54966 &_swigt__p_wxWindow,
54967 &_swigt__p_wxWindowCreateEvent,
54968 &_swigt__p_wxWindowDestroyEvent,
54969 &_swigt__p_wxXPMHandler,
54970 &_swigt__p_wxZipFSHandler,
54971 };
54972
54973 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54974 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54975 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54976 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54977 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54978 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54979 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54980 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54981 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54982 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54983 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54984 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54985 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54986 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54987 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}};
54988 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54989 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}};
54990 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54991 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}};
54992 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54993 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54994 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
54995 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54996 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54997 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}};
54998 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54999 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}};
55000 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55001 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55002 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55003 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55004 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55005 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55006 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55007 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55008 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55009 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}};
55010 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55011 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55012 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}};
55013 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55014 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55015 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}};
55016 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}};
55017 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55018 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55019 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55020 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55021 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55022 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55023 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55024 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55025 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}};
55026 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55027 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}};
55028 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55029 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55030 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55031 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}};
55032 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55033 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55034 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55035 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55036 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55037 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55038 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55039 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}};
55040 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55041 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55042 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55043 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55044 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55045 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55046 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55047 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55048 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55049 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55050 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55051 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55052 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55053 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55054 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55055 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55056 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}};
55057 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55058 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55059 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55060 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55061 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55062 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55063 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55064 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55065 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55066 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55067 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55068 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55069 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55070 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55071 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55072 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55073 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55074 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55075 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55076 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55077 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55078 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55079 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55080 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55081 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55082 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55083 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55084 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55085 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55086 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55087 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55088 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}};
55089 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}};
55090 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55092 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55093 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55094 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55095 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55096 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55097 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}};
55098 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55099 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}};
55100 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55101 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55102 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55103 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55104
55105 static swig_cast_info *swig_cast_initial[] = {
55106 _swigc__p_buffer,
55107 _swigc__p_char,
55108 _swigc__p_form_ops_t,
55109 _swigc__p_int,
55110 _swigc__p_long,
55111 _swigc__p_unsigned_char,
55112 _swigc__p_unsigned_int,
55113 _swigc__p_unsigned_long,
55114 _swigc__p_wxANIHandler,
55115 _swigc__p_wxAcceleratorEntry,
55116 _swigc__p_wxAcceleratorTable,
55117 _swigc__p_wxActivateEvent,
55118 _swigc__p_wxAppTraits,
55119 _swigc__p_wxArrayString,
55120 _swigc__p_wxBMPHandler,
55121 _swigc__p_wxBitmap,
55122 _swigc__p_wxBoxSizer,
55123 _swigc__p_wxButton,
55124 _swigc__p_wxCURHandler,
55125 _swigc__p_wxCaret,
55126 _swigc__p_wxChildFocusEvent,
55127 _swigc__p_wxClipboardTextEvent,
55128 _swigc__p_wxCloseEvent,
55129 _swigc__p_wxColour,
55130 _swigc__p_wxCommandEvent,
55131 _swigc__p_wxContextMenuEvent,
55132 _swigc__p_wxControl,
55133 _swigc__p_wxControlWithItems,
55134 _swigc__p_wxCursor,
55135 _swigc__p_wxDC,
55136 _swigc__p_wxDateEvent,
55137 _swigc__p_wxDateTime,
55138 _swigc__p_wxDisplayChangedEvent,
55139 _swigc__p_wxDropFilesEvent,
55140 _swigc__p_wxDuplexMode,
55141 _swigc__p_wxEraseEvent,
55142 _swigc__p_wxEvent,
55143 _swigc__p_wxEventLoop,
55144 _swigc__p_wxEventLoopActivator,
55145 _swigc__p_wxEvtHandler,
55146 _swigc__p_wxFSFile,
55147 _swigc__p_wxFileSystem,
55148 _swigc__p_wxFileSystemHandler,
55149 _swigc__p_wxFlexGridSizer,
55150 _swigc__p_wxFocusEvent,
55151 _swigc__p_wxFont,
55152 _swigc__p_wxFrame,
55153 _swigc__p_wxGBPosition,
55154 _swigc__p_wxGBSizerItem,
55155 _swigc__p_wxGBSpan,
55156 _swigc__p_wxGIFHandler,
55157 _swigc__p_wxGridBagSizer,
55158 _swigc__p_wxGridSizer,
55159 _swigc__p_wxHelpEvent__Origin,
55160 _swigc__p_wxICOHandler,
55161 _swigc__p_wxIconizeEvent,
55162 _swigc__p_wxIdleEvent,
55163 _swigc__p_wxImage,
55164 _swigc__p_wxImageHandler,
55165 _swigc__p_wxImageHistogram,
55166 _swigc__p_wxImage_HSVValue,
55167 _swigc__p_wxImage_RGBValue,
55168 _swigc__p_wxIndividualLayoutConstraint,
55169 _swigc__p_wxInitDialogEvent,
55170 _swigc__p_wxInputStream,
55171 _swigc__p_wxInternetFSHandler,
55172 _swigc__p_wxItemContainer,
55173 _swigc__p_wxJPEGHandler,
55174 _swigc__p_wxKeyEvent,
55175 _swigc__p_wxLayoutConstraints,
55176 _swigc__p_wxMaximizeEvent,
55177 _swigc__p_wxMemoryFSHandler,
55178 _swigc__p_wxMenu,
55179 _swigc__p_wxMenuBar,
55180 _swigc__p_wxMenuBarBase,
55181 _swigc__p_wxMenuEvent,
55182 _swigc__p_wxMenuItem,
55183 _swigc__p_wxMouseCaptureChangedEvent,
55184 _swigc__p_wxMouseEvent,
55185 _swigc__p_wxMoveEvent,
55186 _swigc__p_wxNavigationKeyEvent,
55187 _swigc__p_wxNcPaintEvent,
55188 _swigc__p_wxNotifyEvent,
55189 _swigc__p_wxObject,
55190 _swigc__p_wxOutputStream,
55191 _swigc__p_wxPCXHandler,
55192 _swigc__p_wxPNGHandler,
55193 _swigc__p_wxPNMHandler,
55194 _swigc__p_wxPaintEvent,
55195 _swigc__p_wxPaletteChangedEvent,
55196 _swigc__p_wxPaperSize,
55197 _swigc__p_wxPoint,
55198 _swigc__p_wxPoint2D,
55199 _swigc__p_wxPropagateOnce,
55200 _swigc__p_wxPropagationDisabler,
55201 _swigc__p_wxPyApp,
55202 _swigc__p_wxPyCommandEvent,
55203 _swigc__p_wxPyDropTarget,
55204 _swigc__p_wxPyEvent,
55205 _swigc__p_wxPyFileSystemHandler,
55206 _swigc__p_wxPyImageHandler,
55207 _swigc__p_wxPyInputStream,
55208 _swigc__p_wxPySizer,
55209 _swigc__p_wxPyValidator,
55210 _swigc__p_wxQuantize,
55211 _swigc__p_wxQueryNewPaletteEvent,
55212 _swigc__p_wxRealPoint,
55213 _swigc__p_wxRect,
55214 _swigc__p_wxRegion,
55215 _swigc__p_wxScrollEvent,
55216 _swigc__p_wxScrollWinEvent,
55217 _swigc__p_wxSetCursorEvent,
55218 _swigc__p_wxShowEvent,
55219 _swigc__p_wxSize,
55220 _swigc__p_wxSizeEvent,
55221 _swigc__p_wxSizer,
55222 _swigc__p_wxSizerItem,
55223 _swigc__p_wxStaticBox,
55224 _swigc__p_wxStaticBoxSizer,
55225 _swigc__p_wxStdDialogButtonSizer,
55226 _swigc__p_wxSysColourChangedEvent,
55227 _swigc__p_wxTIFFHandler,
55228 _swigc__p_wxToolTip,
55229 _swigc__p_wxUpdateUIEvent,
55230 _swigc__p_wxValidator,
55231 _swigc__p_wxVisualAttributes,
55232 _swigc__p_wxWindow,
55233 _swigc__p_wxWindowCreateEvent,
55234 _swigc__p_wxWindowDestroyEvent,
55235 _swigc__p_wxXPMHandler,
55236 _swigc__p_wxZipFSHandler,
55237 };
55238
55239
55240 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55241
55242 static swig_const_info swig_const_table[] = {
55243 {0, 0, 0, 0.0, 0, 0}};
55244
55245 #ifdef __cplusplus
55246 }
55247 #endif
55248 /* -----------------------------------------------------------------------------
55249 * Type initialization:
55250 * This problem is tough by the requirement that no dynamic
55251 * memory is used. Also, since swig_type_info structures store pointers to
55252 * swig_cast_info structures and swig_cast_info structures store pointers back
55253 * to swig_type_info structures, we need some lookup code at initialization.
55254 * The idea is that swig generates all the structures that are needed.
55255 * The runtime then collects these partially filled structures.
55256 * The SWIG_InitializeModule function takes these initial arrays out of
55257 * swig_module, and does all the lookup, filling in the swig_module.types
55258 * array with the correct data and linking the correct swig_cast_info
55259 * structures together.
55260 *
55261 * The generated swig_type_info structures are assigned staticly to an initial
55262 * array. We just loop though that array, and handle each type individually.
55263 * First we lookup if this type has been already loaded, and if so, use the
55264 * loaded structure instead of the generated one. Then we have to fill in the
55265 * cast linked list. The cast data is initially stored in something like a
55266 * two-dimensional array. Each row corresponds to a type (there are the same
55267 * number of rows as there are in the swig_type_initial array). Each entry in
55268 * a column is one of the swig_cast_info structures for that type.
55269 * The cast_initial array is actually an array of arrays, because each row has
55270 * a variable number of columns. So to actually build the cast linked list,
55271 * we find the array of casts associated with the type, and loop through it
55272 * adding the casts to the list. The one last trick we need to do is making
55273 * sure the type pointer in the swig_cast_info struct is correct.
55274 *
55275 * First off, we lookup the cast->type name to see if it is already loaded.
55276 * There are three cases to handle:
55277 * 1) If the cast->type has already been loaded AND the type we are adding
55278 * casting info to has not been loaded (it is in this module), THEN we
55279 * replace the cast->type pointer with the type pointer that has already
55280 * been loaded.
55281 * 2) If BOTH types (the one we are adding casting info to, and the
55282 * cast->type) are loaded, THEN the cast info has already been loaded by
55283 * the previous module so we just ignore it.
55284 * 3) Finally, if cast->type has not already been loaded, then we add that
55285 * swig_cast_info to the linked list (because the cast->type) pointer will
55286 * be correct.
55287 * ----------------------------------------------------------------------------- */
55288
55289 #ifdef __cplusplus
55290 extern "C" {
55291 #if 0
55292 } /* c-mode */
55293 #endif
55294 #endif
55295
55296 #if 0
55297 #define SWIGRUNTIME_DEBUG
55298 #endif
55299
55300 SWIGRUNTIME void
55301 SWIG_InitializeModule(void *clientdata) {
55302 size_t i;
55303 swig_module_info *module_head;
55304 static int init_run = 0;
55305
55306 clientdata = clientdata;
55307
55308 if (init_run) return;
55309 init_run = 1;
55310
55311 /* Initialize the swig_module */
55312 swig_module.type_initial = swig_type_initial;
55313 swig_module.cast_initial = swig_cast_initial;
55314
55315 /* Try and load any already created modules */
55316 module_head = SWIG_GetModule(clientdata);
55317 if (module_head) {
55318 swig_module.next = module_head->next;
55319 module_head->next = &swig_module;
55320 } else {
55321 /* This is the first module loaded */
55322 swig_module.next = &swig_module;
55323 SWIG_SetModule(clientdata, &swig_module);
55324 }
55325
55326 /* Now work on filling in swig_module.types */
55327 #ifdef SWIGRUNTIME_DEBUG
55328 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55329 #endif
55330 for (i = 0; i < swig_module.size; ++i) {
55331 swig_type_info *type = 0;
55332 swig_type_info *ret;
55333 swig_cast_info *cast;
55334
55335 #ifdef SWIGRUNTIME_DEBUG
55336 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55337 #endif
55338
55339 /* if there is another module already loaded */
55340 if (swig_module.next != &swig_module) {
55341 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55342 }
55343 if (type) {
55344 /* Overwrite clientdata field */
55345 #ifdef SWIGRUNTIME_DEBUG
55346 printf("SWIG_InitializeModule: found type %s\n", type->name);
55347 #endif
55348 if (swig_module.type_initial[i]->clientdata) {
55349 type->clientdata = swig_module.type_initial[i]->clientdata;
55350 #ifdef SWIGRUNTIME_DEBUG
55351 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55352 #endif
55353 }
55354 } else {
55355 type = swig_module.type_initial[i];
55356 }
55357
55358 /* Insert casting types */
55359 cast = swig_module.cast_initial[i];
55360 while (cast->type) {
55361 /* Don't need to add information already in the list */
55362 ret = 0;
55363 #ifdef SWIGRUNTIME_DEBUG
55364 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55365 #endif
55366 if (swig_module.next != &swig_module) {
55367 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55368 #ifdef SWIGRUNTIME_DEBUG
55369 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55370 #endif
55371 }
55372 if (ret) {
55373 if (type == swig_module.type_initial[i]) {
55374 #ifdef SWIGRUNTIME_DEBUG
55375 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55376 #endif
55377 cast->type = ret;
55378 ret = 0;
55379 } else {
55380 /* Check for casting already in the list */
55381 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55382 #ifdef SWIGRUNTIME_DEBUG
55383 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55384 #endif
55385 if (!ocast) ret = 0;
55386 }
55387 }
55388
55389 if (!ret) {
55390 #ifdef SWIGRUNTIME_DEBUG
55391 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55392 #endif
55393 if (type->cast) {
55394 type->cast->prev = cast;
55395 cast->next = type->cast;
55396 }
55397 type->cast = cast;
55398 }
55399 cast++;
55400 }
55401 /* Set entry in modules->types array equal to the type */
55402 swig_module.types[i] = type;
55403 }
55404 swig_module.types[i] = 0;
55405
55406 #ifdef SWIGRUNTIME_DEBUG
55407 printf("**** SWIG_InitializeModule: Cast List ******\n");
55408 for (i = 0; i < swig_module.size; ++i) {
55409 int j = 0;
55410 swig_cast_info *cast = swig_module.cast_initial[i];
55411 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55412 while (cast->type) {
55413 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55414 cast++;
55415 ++j;
55416 }
55417 printf("---- Total casts: %d\n",j);
55418 }
55419 printf("**** SWIG_InitializeModule: Cast List ******\n");
55420 #endif
55421 }
55422
55423 /* This function will propagate the clientdata field of type to
55424 * any new swig_type_info structures that have been added into the list
55425 * of equivalent types. It is like calling
55426 * SWIG_TypeClientData(type, clientdata) a second time.
55427 */
55428 SWIGRUNTIME void
55429 SWIG_PropagateClientData(void) {
55430 size_t i;
55431 swig_cast_info *equiv;
55432 static int init_run = 0;
55433
55434 if (init_run) return;
55435 init_run = 1;
55436
55437 for (i = 0; i < swig_module.size; i++) {
55438 if (swig_module.types[i]->clientdata) {
55439 equiv = swig_module.types[i]->cast;
55440 while (equiv) {
55441 if (!equiv->converter) {
55442 if (equiv->type && !equiv->type->clientdata)
55443 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55444 }
55445 equiv = equiv->next;
55446 }
55447 }
55448 }
55449 }
55450
55451 #ifdef __cplusplus
55452 #if 0
55453 {
55454 /* c-mode */
55455 #endif
55456 }
55457 #endif
55458
55459
55460
55461 #ifdef __cplusplus
55462 extern "C" {
55463 #endif
55464
55465 /* Python-specific SWIG API */
55466 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55467 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55468 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55469
55470 /* -----------------------------------------------------------------------------
55471 * global variable support code.
55472 * ----------------------------------------------------------------------------- */
55473
55474 typedef struct swig_globalvar {
55475 char *name; /* Name of global variable */
55476 PyObject *(*get_attr)(void); /* Return the current value */
55477 int (*set_attr)(PyObject *); /* Set the value */
55478 struct swig_globalvar *next;
55479 } swig_globalvar;
55480
55481 typedef struct swig_varlinkobject {
55482 PyObject_HEAD
55483 swig_globalvar *vars;
55484 } swig_varlinkobject;
55485
55486 SWIGINTERN PyObject *
55487 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55488 return PyString_FromString("<Swig global variables>");
55489 }
55490
55491 SWIGINTERN PyObject *
55492 swig_varlink_str(swig_varlinkobject *v) {
55493 PyObject *str = PyString_FromString("(");
55494 swig_globalvar *var;
55495 for (var = v->vars; var; var=var->next) {
55496 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55497 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55498 }
55499 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55500 return str;
55501 }
55502
55503 SWIGINTERN int
55504 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55505 PyObject *str = swig_varlink_str(v);
55506 fprintf(fp,"Swig global variables ");
55507 fprintf(fp,"%s\n", PyString_AsString(str));
55508 Py_DECREF(str);
55509 return 0;
55510 }
55511
55512 SWIGINTERN void
55513 swig_varlink_dealloc(swig_varlinkobject *v) {
55514 swig_globalvar *var = v->vars;
55515 while (var) {
55516 swig_globalvar *n = var->next;
55517 free(var->name);
55518 free(var);
55519 var = n;
55520 }
55521 }
55522
55523 SWIGINTERN PyObject *
55524 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55525 PyObject *res = NULL;
55526 swig_globalvar *var = v->vars;
55527 while (var) {
55528 if (strcmp(var->name,n) == 0) {
55529 res = (*var->get_attr)();
55530 break;
55531 }
55532 var = var->next;
55533 }
55534 if (res == NULL && !PyErr_Occurred()) {
55535 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55536 }
55537 return res;
55538 }
55539
55540 SWIGINTERN int
55541 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55542 int res = 1;
55543 swig_globalvar *var = v->vars;
55544 while (var) {
55545 if (strcmp(var->name,n) == 0) {
55546 res = (*var->set_attr)(p);
55547 break;
55548 }
55549 var = var->next;
55550 }
55551 if (res == 1 && !PyErr_Occurred()) {
55552 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55553 }
55554 return res;
55555 }
55556
55557 SWIGINTERN PyTypeObject*
55558 swig_varlink_type(void) {
55559 static char varlink__doc__[] = "Swig var link object";
55560 static PyTypeObject varlink_type;
55561 static int type_init = 0;
55562 if (!type_init) {
55563 const PyTypeObject tmp
55564 = {
55565 PyObject_HEAD_INIT(NULL)
55566 0, /* Number of items in variable part (ob_size) */
55567 (char *)"swigvarlink", /* Type name (tp_name) */
55568 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55569 0, /* Itemsize (tp_itemsize) */
55570 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55571 (printfunc) swig_varlink_print, /* Print (tp_print) */
55572 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55573 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55574 0, /* tp_compare */
55575 (reprfunc) swig_varlink_repr, /* tp_repr */
55576 0, /* tp_as_number */
55577 0, /* tp_as_sequence */
55578 0, /* tp_as_mapping */
55579 0, /* tp_hash */
55580 0, /* tp_call */
55581 (reprfunc)swig_varlink_str, /* tp_str */
55582 0, /* tp_getattro */
55583 0, /* tp_setattro */
55584 0, /* tp_as_buffer */
55585 0, /* tp_flags */
55586 varlink__doc__, /* tp_doc */
55587 0, /* tp_traverse */
55588 0, /* tp_clear */
55589 0, /* tp_richcompare */
55590 0, /* tp_weaklistoffset */
55591 #if PY_VERSION_HEX >= 0x02020000
55592 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55593 #endif
55594 #if PY_VERSION_HEX >= 0x02030000
55595 0, /* tp_del */
55596 #endif
55597 #ifdef COUNT_ALLOCS
55598 0,0,0,0 /* tp_alloc -> tp_next */
55599 #endif
55600 };
55601 varlink_type = tmp;
55602 varlink_type.ob_type = &PyType_Type;
55603 type_init = 1;
55604 }
55605 return &varlink_type;
55606 }
55607
55608 /* Create a variable linking object for use later */
55609 SWIGINTERN PyObject *
55610 SWIG_Python_newvarlink(void) {
55611 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55612 if (result) {
55613 result->vars = 0;
55614 }
55615 return ((PyObject*) result);
55616 }
55617
55618 SWIGINTERN void
55619 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55620 swig_varlinkobject *v = (swig_varlinkobject *) p;
55621 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55622 if (gv) {
55623 size_t size = strlen(name)+1;
55624 gv->name = (char *)malloc(size);
55625 if (gv->name) {
55626 strncpy(gv->name,name,size);
55627 gv->get_attr = get_attr;
55628 gv->set_attr = set_attr;
55629 gv->next = v->vars;
55630 }
55631 }
55632 v->vars = gv;
55633 }
55634
55635 SWIGINTERN PyObject *
55636 SWIG_globals() {
55637 static PyObject *_SWIG_globals = 0;
55638 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55639 return _SWIG_globals;
55640 }
55641
55642 /* -----------------------------------------------------------------------------
55643 * constants/methods manipulation
55644 * ----------------------------------------------------------------------------- */
55645
55646 /* Install Constants */
55647 SWIGINTERN void
55648 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55649 PyObject *obj = 0;
55650 size_t i;
55651 for (i = 0; constants[i].type; ++i) {
55652 switch(constants[i].type) {
55653 case SWIG_PY_POINTER:
55654 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55655 break;
55656 case SWIG_PY_BINARY:
55657 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55658 break;
55659 default:
55660 obj = 0;
55661 break;
55662 }
55663 if (obj) {
55664 PyDict_SetItemString(d, constants[i].name, obj);
55665 Py_DECREF(obj);
55666 }
55667 }
55668 }
55669
55670 /* -----------------------------------------------------------------------------*/
55671 /* Fix SwigMethods to carry the callback ptrs when needed */
55672 /* -----------------------------------------------------------------------------*/
55673
55674 SWIGINTERN void
55675 SWIG_Python_FixMethods(PyMethodDef *methods,
55676 swig_const_info *const_table,
55677 swig_type_info **types,
55678 swig_type_info **types_initial) {
55679 size_t i;
55680 for (i = 0; methods[i].ml_name; ++i) {
55681 const char *c = methods[i].ml_doc;
55682 if (c && (c = strstr(c, "swig_ptr: "))) {
55683 int j;
55684 swig_const_info *ci = 0;
55685 const char *name = c + 10;
55686 for (j = 0; const_table[j].type; ++j) {
55687 if (strncmp(const_table[j].name, name,
55688 strlen(const_table[j].name)) == 0) {
55689 ci = &(const_table[j]);
55690 break;
55691 }
55692 }
55693 if (ci) {
55694 size_t shift = (ci->ptype) - types;
55695 swig_type_info *ty = types_initial[shift];
55696 size_t ldoc = (c - methods[i].ml_doc);
55697 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55698 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55699 if (ndoc) {
55700 char *buff = ndoc;
55701 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55702 if (ptr) {
55703 strncpy(buff, methods[i].ml_doc, ldoc);
55704 buff += ldoc;
55705 strncpy(buff, "swig_ptr: ", 10);
55706 buff += 10;
55707 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55708 methods[i].ml_doc = ndoc;
55709 }
55710 }
55711 }
55712 }
55713 }
55714 }
55715
55716 #ifdef __cplusplus
55717 }
55718 #endif
55719
55720 /* -----------------------------------------------------------------------------*
55721 * Partial Init method
55722 * -----------------------------------------------------------------------------*/
55723
55724 #ifdef __cplusplus
55725 extern "C"
55726 #endif
55727 SWIGEXPORT void SWIG_init(void) {
55728 PyObject *m, *d;
55729
55730 /* Fix SwigMethods to carry the callback ptrs when needed */
55731 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55732
55733 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55734 d = PyModule_GetDict(m);
55735
55736 SWIG_InitializeModule(0);
55737 SWIG_InstallConstants(d,swig_const_table);
55738
55739
55740
55741 #ifndef wxPyUSE_EXPORT
55742 // Make our API structure a CObject so other modules can import it
55743 // from this module.
55744 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55745 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55746 Py_XDECREF(cobj);
55747 #endif
55748
55749 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55750 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55751 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55752 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55753 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55754 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55755 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55756 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55757 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55758 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55759 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55760 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55761 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55762 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55763 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55764 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55765 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55766 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55767 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55768 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55769 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55770 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55771 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55772 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55773 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55774 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55775 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55776 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55777 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55778 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55779 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55780 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55781 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55782 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55783 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55784 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55785 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55786 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55787 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55788 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55789 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55790 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55791 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55792 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55793 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55794 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55795 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55796 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55797 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55798 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55799 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55800 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55801 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55802 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55803 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55804 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55805 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55806 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55807 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55808 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55809 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55810 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55811 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55812 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55813 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55814 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55815 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55816 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55817 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55818 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55819 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55820 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55821 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55822 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55823 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55824 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55825 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55826 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55827 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55828 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55829 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55830 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55831 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55832 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55833 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55834 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55835 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55836 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55837 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55838 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55839 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55840 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55841 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55842 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55843 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55844 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55845 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55846 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55847 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55848 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55849 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55850 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55851 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55852 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55853 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55854 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55855 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55856 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55857 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55858 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55859 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55860 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55861 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55862 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55863 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55864 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55865 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55866 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55867 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55868 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55869 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55870 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55871 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55872 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55873 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55874 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55875 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55876 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55877 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55878 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55879 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55880 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55881 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55882 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55883 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55884 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55885 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55886 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55887 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55888 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55889 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55890 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55891 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55892 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55893 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55894 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55895 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55896 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55897 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55898 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55899 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55900 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55901 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55902 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55903 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55904 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55905 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55906 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55907 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55908 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55909 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55910 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55911 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55912 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55913 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55914 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55915 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55916 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55917 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55918 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55919 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55920 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55921 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55922 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55923 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55924 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55925 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55926 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55927 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55928 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55929 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55930 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55931 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55932 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55933 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55934 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55935 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55936 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55937 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55938 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55939 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55940 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55941 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55942 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55943 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55944 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55945 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55946 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55947 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55948 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55949 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55950 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55951 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55952 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55953 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55954 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55955 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55956 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55957 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55958 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55959 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55960 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55961 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55962 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55963 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55964 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55965 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55966 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55967 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55968 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55969 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55970 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55971 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55972 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55973 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55974 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55975 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55976 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55977 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55978 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55979 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55980 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55981 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55982 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55983 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55984 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55985 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55986 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55987 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55988 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55989 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55990 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55991 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55992 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55993 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55994 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55995 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55996 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55997 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55998 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55999 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56000 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56001 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56002 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56003 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56004 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56005 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56006 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56007 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56008 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56009 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56010 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56011 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56012 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56013 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56014 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56015 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56016 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56017 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56018 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56019 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56020 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56021 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56022 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56023 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56024 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56025 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56026 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56027 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56028 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56029 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56030 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56031 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56032 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56033 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56034 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56035 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56036 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56037 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56038 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56039 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56040 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56041 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56042 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56043 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56044 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56045 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56046 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56047 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56048 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56049 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56050 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56051 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56052 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56053 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56054 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56055 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56056 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56057 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56058 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56059 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56060 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56061 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56062 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56063 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56064 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56065 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56066 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56067 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56068 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56069 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56070 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56071 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56072 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56073 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56074 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56075 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56076 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56077 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56078 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56079 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56080 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56081 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56082 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56083 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56084 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56085 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56086 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56087 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56088 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56089 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56090 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56091 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56092 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56093 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56094 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56095 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56096 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56097 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56098 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56099 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56100 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56101 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56102 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56103 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56104 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56105 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56106 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56107 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56108 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56109 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56110 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56111 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56112 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56113 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56114 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56115 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56116 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56117 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56118 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56119 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56120 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56121 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56122 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56123 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56124 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56125 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56126 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56127 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56128 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56129 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56130 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56131 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56132 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56133 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56134 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56135 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56136 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56137 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56138 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56139 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56140 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56141 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56142 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56143 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56144 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56145 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56146 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56147 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56148 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56149 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56150 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56151 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56152 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56153 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56154 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56155 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56156 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56157 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56158 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56159 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56160 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56161 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56162 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56163 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56164 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56165 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56166 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56167 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56168 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56169 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56170 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56171 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56172 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56173 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56174 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56175 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56176 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56177 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56178 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56179 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56180 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56181 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56182 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56183 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56184 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56185 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56186 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56187 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56188 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56189 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56190 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56191 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56192 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56193 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56194 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56195 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56196 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56197 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56198 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56199 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56200 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56201 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56202 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56203 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56204 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56205 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56206 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56207 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56208 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56209 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56210 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56211 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56212 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56213 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56214 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56215 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56216 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56217 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56218 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56219 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56220 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56221 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56222 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56223 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56224 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56225 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56226 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56227 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56228 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56229 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56230 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56231 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56232 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56233 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56234 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56235 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56236 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56237 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56238 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56239 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56240 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56241 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56242 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56243 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56244 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56245 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56246 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56247 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56248 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56249 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56250 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56251 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56252 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56253 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56254 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56255 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56256 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56257 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56258 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56259 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56260 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56261 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56262 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56263 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56264 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56265 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56266 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56267 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56268 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56269 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56270 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56271 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56272 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56273 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56274 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56275 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56276 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56277 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56278 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56279 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56280 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56281 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56282 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56283 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56284 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56285 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56286 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56287 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56288 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56289 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56290 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56291 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56292 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56293 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56294 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56295 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56296 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56297 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56298 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56299 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56300 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56301 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56302 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56303 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56304 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56305 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56306 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56307 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56308 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56309 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56310 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56311 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56312 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56313 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56314 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56315 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56316 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56317 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56318 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56319 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56320 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56321 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56322 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56323 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56324 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56325 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56326 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56327 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56328 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56329 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56330 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56331 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56332 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56333 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56334 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56335 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56336 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56337 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56338 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56339 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56340 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56341 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56342 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56343 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56344 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56345 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56346 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56347 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56348 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56349 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56350 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56351 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56352 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56353 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56354 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56355 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56356 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56357 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56358 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56359 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56360 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56361 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56362 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56363 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56364 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56365 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56366 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56367 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56368 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56369 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56370 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56371 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56372 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56373 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56374 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56375 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56376 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56377 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56378 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56379 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56380 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56381 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56382 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56383 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56384 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56385 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56386 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56387 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56388 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56389 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56390 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56391 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56392 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56393 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56394 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56395 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56396 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56397 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56398 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56399 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56400 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56401 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56402 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56403 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56404 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56405 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56406 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56407 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56408 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56409 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56410 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56411 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56412
56413 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56414
56415
56416 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56417
56418 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56419 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56420 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56421 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56422 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56423 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56424 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56425 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56426 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56427 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56428 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56429 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56430 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56431 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56432 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56433 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56434 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56435 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56436 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56437 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56438 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56439 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56440 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56441 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56442 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56443 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56444 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56445 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56446 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56447 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56448 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56449 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56450 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56451 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56452 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56453 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56454 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56455 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56456 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56457 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56458 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56459 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56460 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56461 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56462 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56463 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56464 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56465 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56466 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56467 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56468 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56469 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56470 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56471 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56472 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56473 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56474 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56475 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56476 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56477 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56478 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56479 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56480 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56481 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56482 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56483 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56484 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56485 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56486 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56487 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56488 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56489 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56490 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56491 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56492 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56493 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56494 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56495 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56496 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56497 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56498 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56499 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56500 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56501 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56502 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56503 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56504 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56505 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56506 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56507 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56508 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56509 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56510 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56511 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56512 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56513 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56514 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56515 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56516 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56517 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56518 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56519 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56520 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56521 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56522 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56523 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56524 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56525 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56526 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56527 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56528 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56529 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56530 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56531 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56532 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56533 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56534 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56535 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56536 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56537 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56538 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56539 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56540 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56541 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56542 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56543 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56544 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56545 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56546 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56547 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56548 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56549 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56550 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56551 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56552 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56553 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56554 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56555 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56556 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56557 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56558 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56559 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56560 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56561 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56562 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56563 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56564 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56565 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56566 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56567 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56568 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56569 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56570 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56571 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56572 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56573 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56574 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56575 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56576 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56577 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56578 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56579 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56580 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56581 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56582 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56583 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56584 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56585 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56586 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56587 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56588 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56589 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56590 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56591 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56592 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56593 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56594 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56595 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56596 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56597 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56598 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56599 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56600 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56601 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56602 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56603 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56604 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56605 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56606 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56607 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56608 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56609 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56610 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56611 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56612 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56613 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56614 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56615 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56616 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56617 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56618 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56619 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56620 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56621 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56622 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56623 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56624
56625 // Initialize threading, some globals and such
56626 __wxPyPreStart(d);
56627
56628
56629 // Although these are defined in __version__ they need to be here too so
56630 // that an assert can be done to ensure that the wxPython and the wxWindows
56631 // versions match.
56632 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56633 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56634 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56635
56636 }
56637
wxWidgets (Impactor)