]> 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
Forward port from 2.6 branch to avoid wxSTD usage crashes.
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
2484 #define SWIGTYPE_p_wxColour swig_types[22]
2485 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
2486 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
2487 #define SWIGTYPE_p_wxControl swig_types[25]
2488 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
2489 #define SWIGTYPE_p_wxCursor swig_types[27]
2490 #define SWIGTYPE_p_wxDC swig_types[28]
2491 #define SWIGTYPE_p_wxDateEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDateTime swig_types[30]
2493 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
2494 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
2496 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
2497 #define SWIGTYPE_p_wxEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEventLoop swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
2501 #define SWIGTYPE_p_wxFSFile swig_types[39]
2502 #define SWIGTYPE_p_wxFileSystem swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
2504 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2505 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2506 #define SWIGTYPE_p_wxFont swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBPosition swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGBSpan swig_types[48]
2511 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridSizer swig_types[51]
2514 #define SWIGTYPE_p_wxICOHandler swig_types[52]
2515 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
2516 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
2517 #define SWIGTYPE_p_wxImage swig_types[55]
2518 #define SWIGTYPE_p_wxImageHandler swig_types[56]
2519 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
2520 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
2521 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
2522 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
2523 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
2524 #define SWIGTYPE_p_wxInputStream swig_types[62]
2525 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
2526 #define SWIGTYPE_p_wxItemContainer swig_types[64]
2527 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
2528 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
2529 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
2530 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
2532 #define SWIGTYPE_p_wxMenu swig_types[70]
2533 #define SWIGTYPE_p_wxMenuBar swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
2535 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
2536 #define SWIGTYPE_p_wxMenuItem swig_types[74]
2537 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
2540 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxObject swig_types[81]
2544 #define SWIGTYPE_p_wxOutputStream swig_types[82]
2545 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
2546 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
2549 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaperSize swig_types[88]
2551 #define SWIGTYPE_p_wxPoint swig_types[89]
2552 #define SWIGTYPE_p_wxPoint2D swig_types[90]
2553 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
2554 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
2555 #define SWIGTYPE_p_wxPyApp swig_types[93]
2556 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
2557 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
2558 #define SWIGTYPE_p_wxPyEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
2560 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
2562 #define SWIGTYPE_p_wxPySizer swig_types[100]
2563 #define SWIGTYPE_p_wxPyValidator swig_types[101]
2564 #define SWIGTYPE_p_wxQuantize swig_types[102]
2565 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
2566 #define SWIGTYPE_p_wxRealPoint swig_types[104]
2567 #define SWIGTYPE_p_wxRect swig_types[105]
2568 #define SWIGTYPE_p_wxRegion swig_types[106]
2569 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
2570 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
2571 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
2572 #define SWIGTYPE_p_wxShowEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSize swig_types[111]
2574 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSizer swig_types[113]
2576 #define SWIGTYPE_p_wxSizerItem swig_types[114]
2577 #define SWIGTYPE_p_wxStaticBox swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
2579 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
2580 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
2581 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
2582 #define SWIGTYPE_p_wxToolTip swig_types[120]
2583 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
2584 #define SWIGTYPE_p_wxValidator swig_types[122]
2585 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
2586 #define SWIGTYPE_p_wxWindow swig_types[124]
2587 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
2588 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
2589 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
2590 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
2591 static swig_type_info *swig_types[130];
2592 static swig_module_info swig_module = {swig_types, 129, 0, 0, 0, 0};
2593 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2594 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2595
2596 /* -------- TYPES TABLE (END) -------- */
2597
2598 #if (PY_VERSION_HEX <= 0x02000000)
2599 # if !defined(SWIG_PYTHON_CLASSIC)
2600 # error "This python version requires to use swig with the '-classic' option"
2601 # endif
2602 #endif
2603 #if (PY_VERSION_HEX <= 0x02020000)
2604 # error "This python version requires to use swig with the '-nomodern' option"
2605 #endif
2606 #if (PY_VERSION_HEX <= 0x02020000)
2607 # error "This python version requires to use swig with the '-nomodernargs' option"
2608 #endif
2609 #ifndef METH_O
2610 # error "This python version requires to use swig with the '-nofastunpack' option"
2611 #endif
2612
2613 /*-----------------------------------------------
2614 @(target):= _core_.so
2615 ------------------------------------------------*/
2616 #define SWIG_init init_core_
2617
2618 #define SWIG_name "_core_"
2619
2620 #define SWIGVERSION 0x010329
2621
2622
2623 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2624 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2625
2626
2627 #include <stdexcept>
2628
2629
2630 namespace swig {
2631 class PyObject_ptr {
2632 protected:
2633 PyObject *_obj;
2634
2635 public:
2636 PyObject_ptr() :_obj(0)
2637 {
2638 }
2639
2640 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2641 {
2642 Py_XINCREF(_obj);
2643 }
2644
2645 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2646 {
2647 if (initial_ref) Py_XINCREF(_obj);
2648 }
2649
2650 PyObject_ptr & operator=(const PyObject_ptr& item)
2651 {
2652 Py_XINCREF(item._obj);
2653 Py_XDECREF(_obj);
2654 _obj = item._obj;
2655 return *this;
2656 }
2657
2658 ~PyObject_ptr()
2659 {
2660 Py_XDECREF(_obj);
2661 }
2662
2663 operator PyObject *() const
2664 {
2665 return _obj;
2666 }
2667
2668 PyObject *operator->() const
2669 {
2670 return _obj;
2671 }
2672 };
2673 }
2674
2675
2676 namespace swig {
2677 struct PyObject_var : PyObject_ptr {
2678 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2679
2680 PyObject_var & operator = (PyObject* obj)
2681 {
2682 Py_XDECREF(_obj);
2683 _obj = obj;
2684 return *this;
2685 }
2686 };
2687 }
2688
2689
2690 #include "wx/wxPython/wxPython_int.h"
2691 #include "wx/wxPython/pyclasses.h"
2692
2693
2694 #ifndef wxPyUSE_EXPORT
2695 // Helper functions for dealing with SWIG objects and such. These are
2696 // located here so they know about the SWIG types and functions declared
2697 // in the wrapper code.
2698
2699 #include <wx/hashmap.h>
2700 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2701
2702
2703 // Maintains a hashmap of className to swig_type_info pointers. Given the
2704 // name of a class either looks up the type info in the cache, or scans the
2705 // SWIG tables for it.
2706 extern PyObject* wxPyPtrTypeMap;
2707 static
2708 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2709
2710 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2711
2712 if (typeInfoCache == NULL)
2713 typeInfoCache = new wxPyTypeInfoHashMap;
2714
2715 wxString name(className);
2716 swig_type_info* swigType = (*typeInfoCache)[name];
2717
2718 if (! swigType) {
2719 // it wasn't in the cache, so look it up from SWIG
2720 name.Append(wxT(" *"));
2721 swigType = SWIG_TypeQuery(name.mb_str());
2722
2723 // if it still wasn't found, try looking for a mapped name
2724 if (!swigType) {
2725 PyObject* item;
2726 name = className;
2727
2728 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2729 (char*)(const char*)name.mbc_str())) != NULL) {
2730 name = wxString(PyString_AsString(item), *wxConvCurrent);
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733 }
2734 }
2735 if (swigType) {
2736 // and add it to the map if found
2737 (*typeInfoCache)[className] = swigType;
2738 }
2739 }
2740 return swigType;
2741 }
2742
2743
2744 // Check if a class name is a type known to SWIG
2745 bool wxPyCheckSwigType(const wxChar* className) {
2746
2747 swig_type_info* swigType = wxPyFindSwigType(className);
2748 return swigType != NULL;
2749 }
2750
2751
2752 // Given a pointer to a C++ object and a class name, construct a Python proxy
2753 // object for it.
2754 PyObject* wxPyConstructObject(void* ptr,
2755 const wxChar* className,
2756 int setThisOwn) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2760
2761 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2762 }
2763
2764
2765 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2766 // Ensures that the proxy object is of the specified (or derived) type. If
2767 // not able to perform the conversion then a Python exception is set and the
2768 // error should be handled properly in the caller. Returns True on success.
2769 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2770 const wxChar* className) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2774
2775 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2776 }
2777
2778
2779
2780 // Make a SWIGified pointer object suitable for a .this attribute
2781 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2782
2783 PyObject* robj = NULL;
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2787
2788 robj = PySwigObject_New(ptr, swigType, 0);
2789 return robj;
2790 }
2791
2792
2793 // Python's PyInstance_Check does not return True for instances of new-style
2794 // classes. This should get close enough for both new and old classes but I
2795 // should re-evaluate the need for doing instance checks...
2796 bool wxPyInstance_Check(PyObject* obj) {
2797 return PyObject_HasAttrString(obj, "__class__") != 0;
2798 }
2799
2800
2801 // This one checks if the object is an instance of a SWIG proxy class (it has
2802 // a .this attribute, and the .this attribute is a PySwigObject.)
2803 bool wxPySwigInstance_Check(PyObject* obj) {
2804 static PyObject* this_str = NULL;
2805 if (this_str == NULL)
2806 this_str = PyString_FromString("this");
2807
2808 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2809 if (this_attr) {
2810 bool retval = (PySwigObject_Check(this_attr) != 0);
2811 Py_DECREF(this_attr);
2812 return retval;
2813 }
2814
2815 PyErr_Clear();
2816 return false;
2817 }
2818
2819
2820 // Export a C API in a struct. Other modules will be able to load this from
2821 // the wx._core_ module and will then have safe access to these functions,
2822 // even if they are located in another shared library.
2823 static wxPyCoreAPI API = {
2824
2825 wxPyCheckSwigType,
2826 wxPyConstructObject,
2827 wxPyConvertSwigPtr,
2828 wxPyMakeSwigPtr,
2829
2830 wxPyBeginAllowThreads,
2831 wxPyEndAllowThreads,
2832 wxPyBeginBlockThreads,
2833 wxPyEndBlockThreads,
2834
2835 wxPy_ConvertList,
2836
2837 wxString_in_helper,
2838 Py2wxString,
2839 wx2PyString,
2840
2841 byte_LIST_helper,
2842 int_LIST_helper,
2843 long_LIST_helper,
2844 string_LIST_helper,
2845 wxPoint_LIST_helper,
2846 wxBitmap_LIST_helper,
2847 wxString_LIST_helper,
2848 wxAcceleratorEntry_LIST_helper,
2849
2850 wxSize_helper,
2851 wxPoint_helper,
2852 wxRealPoint_helper,
2853 wxRect_helper,
2854 wxColour_helper,
2855 wxPoint2D_helper,
2856
2857 wxPySimple_typecheck,
2858 wxColour_typecheck,
2859
2860 wxPyCBH_setCallbackInfo,
2861 wxPyCBH_findCallback,
2862 wxPyCBH_callCallback,
2863 wxPyCBH_callCallbackObj,
2864 wxPyCBH_delete,
2865
2866 wxPyMake_wxObject,
2867 wxPyMake_wxSizer,
2868 wxPyPtrTypeMap_Add,
2869 wxPy2int_seq_helper,
2870 wxPy4int_seq_helper,
2871 wxArrayString2PyList_helper,
2872 wxArrayInt2PyList_helper,
2873
2874 wxPyClientData_dtor,
2875 wxPyUserData_dtor,
2876 wxPyOORClientData_dtor,
2877
2878 wxPyCBInputStream_create,
2879 wxPyCBInputStream_copy,
2880
2881 wxPyInstance_Check,
2882 wxPySwigInstance_Check,
2883
2884 wxPyCheckForApp
2885
2886 };
2887
2888 #endif
2889
2890
2891 #if !WXWIN_COMPATIBILITY_2_4
2892 #define wxHIDE_READONLY 0
2893 #endif
2894
2895
2896 #define SWIG_From_long PyInt_FromLong
2897
2898
2899 SWIGINTERNINLINE PyObject *
2900 SWIG_From_int (int value)
2901 {
2902 return SWIG_From_long (value);
2903 }
2904
2905 static const wxString wxPyEmptyString(wxEmptyString);
2906 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2907 return self->GetClassInfo()->GetClassName();
2908 }
2909 SWIGINTERN void wxObject_Destroy(wxObject *self){
2910 delete self;
2911 }
2912
2913 #ifndef __WXMAC__
2914 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2915 #endif
2916
2917
2918 #include <limits.h>
2919 #ifndef LLONG_MIN
2920 # define LLONG_MIN LONG_LONG_MIN
2921 #endif
2922 #ifndef LLONG_MAX
2923 # define LLONG_MAX LONG_LONG_MAX
2924 #endif
2925 #ifndef ULLONG_MAX
2926 # define ULLONG_MAX ULONG_LONG_MAX
2927 #endif
2928
2929
2930 SWIGINTERN int
2931 SWIG_AsVal_long (PyObject* obj, long* val)
2932 {
2933 if (PyNumber_Check(obj)) {
2934 if (val) *val = PyInt_AsLong(obj);
2935 return SWIG_OK;
2936 }
2937 return SWIG_TypeError;
2938 }
2939
2940
2941 SWIGINTERN int
2942 SWIG_AsVal_int (PyObject * obj, int *val)
2943 {
2944 long v;
2945 int res = SWIG_AsVal_long (obj, &v);
2946 if (SWIG_IsOK(res)) {
2947 if ((v < INT_MIN || v > INT_MAX)) {
2948 return SWIG_OverflowError;
2949 } else {
2950 if (val) *val = static_cast< int >(v);
2951 }
2952 }
2953 return res;
2954 }
2955
2956 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2958 PyObject* tup = PyTuple_New(2);
2959 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2960 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2961 wxPyEndBlockThreads(blocked);
2962 return tup;
2963 }
2964
2965 SWIGINTERN int
2966 SWIG_AsVal_double (PyObject *obj, double* val)
2967 {
2968 if (PyNumber_Check(obj)) {
2969 if (val) *val = PyFloat_AsDouble(obj);
2970 return SWIG_OK;
2971 }
2972 return SWIG_TypeError;
2973 }
2974
2975
2976 #define SWIG_From_double PyFloat_FromDouble
2977
2978 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
2979 self->x = x;
2980 self->y = y;
2981 }
2982 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
2983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2984 PyObject* tup = PyTuple_New(2);
2985 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
2986 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
2987 wxPyEndBlockThreads(blocked);
2988 return tup;
2989 }
2990 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
2991 self->x = x;
2992 self->y = y;
2993 }
2994 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
2995 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2996 PyObject* tup = PyTuple_New(2);
2997 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2998 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2999 wxPyEndBlockThreads(blocked);
3000 return tup;
3001 }
3002 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3003 self->x = x;
3004 self->y = y;
3005 self->width = width;
3006 self->height = height;
3007 }
3008 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3009 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3010 PyObject* tup = PyTuple_New(4);
3011 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3012 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3013 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3014 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3015 wxPyEndBlockThreads(blocked);
3016 return tup;
3017 }
3018
3019 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3020 wxRegion reg1(*r1);
3021 wxRegion reg2(*r2);
3022 wxRect dest(0,0,0,0);
3023 PyObject* obj;
3024
3025 reg1.Intersect(reg2);
3026 dest = reg1.GetBox();
3027
3028 if (dest != wxRect(0,0,0,0)) {
3029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3030 wxRect* newRect = new wxRect(dest);
3031 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3032 wxPyEndBlockThreads(blocked);
3033 return obj;
3034 }
3035 Py_INCREF(Py_None);
3036 return Py_None;
3037 }
3038
3039 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3040 self->m_x = x;
3041 self->m_y = y;
3042 }
3043 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3045 PyObject* tup = PyTuple_New(2);
3046 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3047 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3048 wxPyEndBlockThreads(blocked);
3049 return tup;
3050 }
3051
3052 #include "wx/wxPython/pyistream.h"
3053
3054 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3055 wxInputStream* wxis = wxPyCBInputStream::create(p);
3056 if (wxis)
3057 return new wxPyInputStream(wxis);
3058 else
3059 return NULL;
3060 }
3061
3062 SWIGINTERN swig_type_info*
3063 SWIG_pchar_descriptor()
3064 {
3065 static int init = 0;
3066 static swig_type_info* info = 0;
3067 if (!init) {
3068 info = SWIG_TypeQuery("_p_char");
3069 init = 1;
3070 }
3071 return info;
3072 }
3073
3074
3075 SWIGINTERNINLINE PyObject *
3076 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3077 {
3078 if (carray) {
3079 if (size > INT_MAX) {
3080 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3081 return pchar_descriptor ?
3082 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3083 } else {
3084 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3085 }
3086 } else {
3087 return SWIG_Py_Void();
3088 }
3089 }
3090
3091
3092 SWIGINTERNINLINE PyObject *
3093 SWIG_From_char (char c)
3094 {
3095 return SWIG_FromCharPtrAndSize(&c,1);
3096 }
3097
3098
3099 SWIGINTERNINLINE PyObject*
3100 SWIG_From_unsigned_SS_long (unsigned long value)
3101 {
3102 return (value > LONG_MAX) ?
3103 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3104 }
3105
3106
3107 SWIGINTERNINLINE PyObject *
3108 SWIG_From_size_t (size_t value)
3109 {
3110 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3111 }
3112
3113
3114 SWIGINTERN int
3115 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3116 {
3117 if (PyString_Check(obj)) {
3118 char *cstr; int len;
3119 PyString_AsStringAndSize(obj, &cstr, &len);
3120 if (cptr) {
3121 if (alloc) {
3122 /*
3123 In python the user should not be able to modify the inner
3124 string representation. To warranty that, if you define
3125 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3126 buffer is always returned.
3127
3128 The default behavior is just to return the pointer value,
3129 so, be careful.
3130 */
3131 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3132 if (*alloc != SWIG_OLDOBJ)
3133 #else
3134 if (*alloc == SWIG_NEWOBJ)
3135 #endif
3136 {
3137 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3138 *alloc = SWIG_NEWOBJ;
3139 }
3140 else {
3141 *cptr = cstr;
3142 *alloc = SWIG_OLDOBJ;
3143 }
3144 } else {
3145 *cptr = PyString_AsString(obj);
3146 }
3147 }
3148 if (psize) *psize = len + 1;
3149 return SWIG_OK;
3150 } else {
3151 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3152 if (pchar_descriptor) {
3153 void* vptr = 0;
3154 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3155 if (cptr) *cptr = (char *) vptr;
3156 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3157 if (alloc) *alloc = SWIG_OLDOBJ;
3158 return SWIG_OK;
3159 }
3160 }
3161 }
3162 return SWIG_TypeError;
3163 }
3164
3165
3166 SWIGINTERN int
3167 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3168 {
3169 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3170 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3171 if (SWIG_IsOK(res)) {
3172 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3173 if (csize <= size) {
3174 if (val) {
3175 if (csize) memcpy(val, cptr, csize*sizeof(char));
3176 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3177 }
3178 if (alloc == SWIG_NEWOBJ) {
3179 delete[] cptr;
3180 res = SWIG_DelNewMask(res);
3181 }
3182 return res;
3183 }
3184 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3185 }
3186 return SWIG_TypeError;
3187 }
3188
3189
3190 SWIGINTERN int
3191 SWIG_AsVal_char (PyObject * obj, char *val)
3192 {
3193 int res = SWIG_AsCharArray(obj, val, 1);
3194 if (!SWIG_IsOK(res)) {
3195 long v;
3196 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3197 if (SWIG_IsOK(res)) {
3198 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3199 if (val) *val = static_cast< char >(v);
3200 } else {
3201 res = SWIG_OverflowError;
3202 }
3203 }
3204 }
3205 return res;
3206 }
3207
3208 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3209 // We use only strings for the streams, not unicode
3210 PyObject* str = PyObject_Str(obj);
3211 if (! str) {
3212 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3213 return;
3214 }
3215 self->Write(PyString_AS_STRING(str),
3216 PyString_GET_SIZE(str));
3217 Py_DECREF(str);
3218 }
3219
3220 #include "wx/wxPython/pyistream.h"
3221
3222
3223 class wxPyFileSystemHandler : public wxFileSystemHandler
3224 {
3225 public:
3226 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3227
3228 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3229 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3230 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3231 DEC_PYCALLBACK_STRING__pure(FindNext);
3232
3233 wxString GetProtocol(const wxString& location) {
3234 return wxFileSystemHandler::GetProtocol(location);
3235 }
3236
3237 wxString GetLeftLocation(const wxString& location) {
3238 return wxFileSystemHandler::GetLeftLocation(location);
3239 }
3240
3241 wxString GetAnchor(const wxString& location) {
3242 return wxFileSystemHandler::GetAnchor(location);
3243 }
3244
3245 wxString GetRightLocation(const wxString& location) {
3246 return wxFileSystemHandler::GetRightLocation(location);
3247 }
3248
3249 wxString GetMimeTypeFromExt(const wxString& location) {
3250 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3251 }
3252
3253 PYPRIVATE;
3254 };
3255
3256
3257 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3258 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3259 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3260 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3261
3262
3263 SWIGINTERN int
3264 SWIG_AsVal_bool (PyObject *obj, bool *val)
3265 {
3266 if (obj == Py_True) {
3267 if (val) *val = true;
3268 return SWIG_OK;
3269 } else if (obj == Py_False) {
3270 if (val) *val = false;
3271 return SWIG_OK;
3272 } else {
3273 long v = 0;
3274 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3275 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3276 return res;
3277 }
3278 }
3279
3280 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3281 wxFileName fname = wxFileSystem::URLToFileName(url);
3282 return fname.GetFullPath();
3283 }
3284
3285 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3286 wxImage& image,
3287 long type) {
3288 wxMemoryFSHandler::AddFile(filename, image, type);
3289 }
3290
3291 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3292 const wxBitmap& bitmap,
3293 long type) {
3294 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3295 }
3296
3297 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3298 PyObject* data) {
3299 if (! PyString_Check(data)) {
3300 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3301 "Expected string object"));
3302 return;
3303 }
3304
3305 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3306 void* ptr = (void*)PyString_AsString(data);
3307 size_t size = PyString_Size(data);
3308 wxPyEndBlockThreads(blocked);
3309
3310 wxMemoryFSHandler::AddFile(filename, ptr, size);
3311 }
3312
3313
3314 #include "wx/wxPython/pyistream.h"
3315
3316
3317 SWIGINTERN int
3318 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3319 {
3320 long v = 0;
3321 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3322 return SWIG_TypeError;
3323 }
3324 else if (val)
3325 *val = (unsigned long)v;
3326 return SWIG_OK;
3327 }
3328
3329
3330 SWIGINTERN int
3331 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3332 {
3333 unsigned long v;
3334 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3335 if (SWIG_IsOK(res)) {
3336 if ((v > UCHAR_MAX)) {
3337 return SWIG_OverflowError;
3338 } else {
3339 if (val) *val = static_cast< unsigned char >(v);
3340 }
3341 }
3342 return res;
3343 }
3344
3345
3346 SWIGINTERNINLINE PyObject *
3347 SWIG_From_unsigned_SS_char (unsigned char value)
3348 {
3349 return SWIG_From_unsigned_SS_long (value);
3350 }
3351
3352 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3353 wxImageHistogramEntry e = (*self)[key];
3354 return e.value;
3355 }
3356 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3357 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3358 wxImageHistogramEntry e = (*self)[key];
3359 return e.value;
3360 }
3361 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3362 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3363 colour.Green(),
3364 colour.Blue());
3365 wxImageHistogramEntry e = (*self)[key];
3366 return e.value;
3367 }
3368
3369 typedef unsigned char* buffer;
3370
3371
3372 // Pull the nested class out to the top level for SWIG's sake
3373 #define wxImage_RGBValue wxImage::RGBValue
3374 #define wxImage_HSVValue wxImage::HSVValue
3375
3376 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3377 if (width > 0 && height > 0)
3378 return new wxImage(width, height, clear);
3379 else
3380 return new wxImage;
3381 }
3382 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3383 return new wxImage(bitmap.ConvertToImage());
3384 }
3385 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3386 if (DATASIZE != width*height*3) {
3387 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3388 return NULL;
3389 }
3390
3391 // Copy the source data so the wxImage can clean it up later
3392 buffer copy = (buffer)malloc(DATASIZE);
3393 if (copy == NULL) {
3394 wxPyBLOCK_THREADS(PyErr_NoMemory());
3395 return NULL;
3396 }
3397 memcpy(copy, data, DATASIZE);
3398 return new wxImage(width, height, copy, false);
3399 }
3400 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3401 if (DATASIZE != width*height*3) {
3402 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3403 return NULL;
3404 }
3405 if (ALPHASIZE != width*height) {
3406 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3407 return NULL;
3408 }
3409
3410 // Copy the source data so the wxImage can clean it up later
3411 buffer dcopy = (buffer)malloc(DATASIZE);
3412 if (dcopy == NULL) {
3413 wxPyBLOCK_THREADS(PyErr_NoMemory());
3414 return NULL;
3415 }
3416 memcpy(dcopy, data, DATASIZE);
3417
3418 buffer acopy = (buffer)malloc(ALPHASIZE);
3419 if (acopy == NULL) {
3420 wxPyBLOCK_THREADS(PyErr_NoMemory());
3421 return NULL;
3422 }
3423 memcpy(acopy, alpha, ALPHASIZE);
3424
3425 return new wxImage(width, height, dcopy, acopy, false);
3426 }
3427 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3428 wxSize size(self->GetWidth(), self->GetHeight());
3429 return size;
3430 }
3431 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3432 buffer data = self->GetData();
3433 int len = self->GetWidth() * self->GetHeight() * 3;
3434 PyObject* rv;
3435 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3436 return rv;
3437 }
3438 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3439 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3440 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3441 return;
3442 }
3443 buffer copy = (buffer)malloc(DATASIZE);
3444 if (copy == NULL) {
3445 wxPyBLOCK_THREADS(PyErr_NoMemory());
3446 return;
3447 }
3448 memcpy(copy, data, DATASIZE);
3449 self->SetData(copy, false);
3450 // wxImage takes ownership of copy...
3451 }
3452 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3453 buffer data = self->GetData();
3454 int len = self->GetWidth() * self->GetHeight() * 3;
3455 PyObject* rv;
3456 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3457 return rv;
3458 }
3459 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3460 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3461 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3462 return;
3463 }
3464 self->SetData(data, true);
3465 }
3466 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3467 buffer data = self->GetAlpha();
3468 if (! data) {
3469 RETURN_NONE();
3470 } else {
3471 int len = self->GetWidth() * self->GetHeight();
3472 PyObject* rv;
3473 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3474 return rv;
3475 }
3476 }
3477 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3478 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3479 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3480 return;
3481 }
3482 buffer acopy = (buffer)malloc(ALPHASIZE);
3483 if (acopy == NULL) {
3484 wxPyBLOCK_THREADS(PyErr_NoMemory());
3485 return;
3486 }
3487 memcpy(acopy, alpha, ALPHASIZE);
3488 self->SetAlpha(acopy, false);
3489 // wxImage takes ownership of acopy...
3490 }
3491 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3492 buffer data = self->GetAlpha();
3493 int len = self->GetWidth() * self->GetHeight();
3494 PyObject* rv;
3495 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3496 return rv;
3497 }
3498 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3499 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3500 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3501 return;
3502 }
3503 self->SetAlpha(alpha, true);
3504 }
3505 SWIGINTERN PyObject *wxImage_GetHandlers(){
3506 wxList& list = wxImage::GetHandlers();
3507 return wxPy_ConvertList(&list);
3508 }
3509 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3510 wxBitmap bitmap(*self, depth);
3511 return bitmap;
3512 }
3513 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3514 wxImage mono = self->ConvertToMono( red, green, blue );
3515 wxBitmap bitmap( mono, 1 );
3516 return bitmap;
3517 }
3518 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3519 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3520 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3521 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3522 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3523 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3524 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3525 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3526 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3527 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3528 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3529 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3530 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3531 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3532 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3533
3534 #include <wx/quantize.h>
3535
3536 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3537 return wxQuantize::Quantize(src, dest,
3538 //NULL, // palette
3539 desiredNoColours,
3540 NULL, // eightBitData
3541 flags);
3542 }
3543 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3544 if (PyCallable_Check(func)) {
3545 self->Connect(id, lastId, eventType,
3546 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3547 new wxPyCallback(func));
3548 }
3549 else if (func == Py_None) {
3550 self->Disconnect(id, lastId, eventType,
3551 (wxObjectEventFunction)
3552 &wxPyCallback::EventThunker);
3553 }
3554 else {
3555 wxPyBLOCK_THREADS(
3556 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3557 }
3558 }
3559 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3560 return self->Disconnect(id, lastId, eventType,
3561 (wxObjectEventFunction)
3562 &wxPyCallback::EventThunker);
3563 }
3564 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3565 if (_self && _self != Py_None) {
3566 self->SetClientObject(new wxPyOORClientData(_self, incref));
3567 }
3568 else {
3569 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3570 if (data) {
3571 self->SetClientObject(NULL); // This will delete it too
3572 }
3573 }
3574 }
3575
3576 #if ! wxUSE_HOTKEY
3577 #define wxEVT_HOTKEY -9999
3578 #endif
3579
3580 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3581 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3582 if (data) {
3583 Py_INCREF(data->m_obj);
3584 return data->m_obj;
3585 } else {
3586 Py_INCREF(Py_None);
3587 return Py_None;
3588 }
3589 }
3590 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3591 wxPyClientData* data = new wxPyClientData(clientData);
3592 self->SetClientObject(data);
3593 }
3594 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3595 #if wxUSE_UNICODE
3596 return self->GetUnicodeKey();
3597 #else
3598 return 0;
3599 #endif
3600 }
3601
3602 SWIGINTERNINLINE PyObject *
3603 SWIG_From_unsigned_SS_int (unsigned int value)
3604 {
3605 return SWIG_From_unsigned_SS_long (value);
3606 }
3607
3608
3609 SWIGINTERN int
3610 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3611 {
3612 unsigned long v;
3613 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3614 if (SWIG_IsOK(res)) {
3615 if ((v > UINT_MAX)) {
3616 return SWIG_OverflowError;
3617 } else {
3618 if (val) *val = static_cast< unsigned int >(v);
3619 }
3620 }
3621 return res;
3622 }
3623
3624 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3625 self->m_size = size;
3626 }
3627 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3628 int count = self->GetNumberOfFiles();
3629 wxString* files = self->GetFiles();
3630 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3631 PyObject* list = PyList_New(count);
3632
3633 if (!list) {
3634 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3635 wxPyEndBlockThreads(blocked);
3636 return NULL;
3637 }
3638
3639 for (int i=0; i<count; i++) {
3640 PyList_SetItem(list, i, wx2PyString(files[i]));
3641 }
3642 wxPyEndBlockThreads(blocked);
3643 return list;
3644 }
3645
3646
3647 SWIGINTERN wxPyApp *new_wxPyApp(){
3648 wxPythonApp = new wxPyApp();
3649 return wxPythonApp;
3650 }
3651 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3652
3653 void wxApp_CleanUp() {
3654 __wxPyCleanup();
3655 }
3656
3657
3658 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3659
3660
3661
3662
3663
3664 SWIGINTERNINLINE PyObject *
3665 SWIG_FromCharPtr(const char *cptr)
3666 {
3667 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3668 }
3669
3670
3671 #if 0 // #ifdef __WXMAC__
3672
3673 // A dummy class that raises an exception if used...
3674 class wxEventLoop
3675 {
3676 public:
3677 wxEventLoop() { wxPyRaiseNotImplemented(); }
3678 int Run() { return 0; }
3679 void Exit(int rc = 0) {}
3680 bool Pending() const { return false; }
3681 bool Dispatch() { return false; }
3682 bool IsRunning() const { return false; }
3683 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3684 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3685 };
3686
3687 #else
3688
3689 #include <wx/evtloop.h>
3690
3691 #endif
3692
3693
3694
3695 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3696 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3697 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3698 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3699 wxWindowList& list = self->GetChildren();
3700 return wxPy_ConvertList(&list);
3701 }
3702 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3703 #if wxUSE_HOTKEY
3704 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3705 #else
3706 return false;
3707 #endif
3708 }
3709 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3710
3711
3712
3713 return false;
3714
3715 }
3716 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3717 return wxPyGetWinHandle(self);
3718 }
3719 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3720 self->AssociateHandle((WXWidget)handle);
3721 }
3722 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3723
3724 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3725 return wxWindow::FindWindowById(id, parent);
3726 }
3727
3728 wxWindow* wxFindWindowByName( const wxString& name,
3729 const wxWindow *parent = NULL ) {
3730 return wxWindow::FindWindowByName(name, parent);
3731 }
3732
3733 wxWindow* wxFindWindowByLabel( const wxString& label,
3734 const wxWindow *parent = NULL ) {
3735 return wxWindow::FindWindowByLabel(label, parent);
3736 }
3737
3738
3739 #ifdef __WXMSW__
3740 #include <wx/msw/private.h> // to get wxGetWindowId
3741 #endif
3742
3743
3744 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3745 #ifdef __WXMSW__
3746 WXHWND hWnd = (WXHWND)_hWnd;
3747 long id = wxGetWindowId(hWnd);
3748 wxWindow* win = new wxWindow;
3749 if (parent)
3750 parent->AddChild(win);
3751 win->SetEventHandler(win);
3752 win->SetHWND(hWnd);
3753 win->SetId(id);
3754 win->SubclassWin(hWnd);
3755 win->AdoptAttributesFromHWND();
3756 win->SetupColours();
3757 return win;
3758 #else
3759 wxPyRaiseNotImplemented();
3760 return NULL;
3761 #endif
3762 }
3763
3764
3765 PyObject* GetTopLevelWindows() {
3766 return wxPy_ConvertList(&wxTopLevelWindows);
3767 }
3768
3769
3770 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3771 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3772 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3773
3774 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3775
3776
3777 SWIGINTERNINLINE int
3778 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3779 {
3780 unsigned long v;
3781 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3782 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3783 return res;
3784 }
3785
3786 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3787 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3788 wxMenuItemList& list = self->GetMenuItems();
3789 return wxPy_ConvertList(&list);
3790 }
3791 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3792 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3793 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3794 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3795 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3796 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3797 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3798 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3799 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3800 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3801 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3802 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3803 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3804 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3805 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3806 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3807 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3808 static const wxString wxPyControlNameStr(wxControlNameStr);
3809 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3810 if (clientData) {
3811 wxPyClientData* data = new wxPyClientData(clientData);
3812 return self->Append(item, data);
3813 } else
3814 return self->Append(item);
3815 }
3816 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
3817 if (clientData) {
3818 wxPyClientData* data = new wxPyClientData(clientData);
3819 return self->Insert(item, pos, data);
3820 } else
3821 return self->Insert(item, pos);
3822 }
3823 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
3824 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3825 if (data) {
3826 Py_INCREF(data->m_obj);
3827 return data->m_obj;
3828 } else {
3829 Py_INCREF(Py_None);
3830 return Py_None;
3831 }
3832 }
3833 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
3834 wxPyClientData* data = new wxPyClientData(clientData);
3835 self->SetClientObject(n, data);
3836 }
3837
3838
3839 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3840 wxPyUserData* data = NULL;
3841 if ( userData ) {
3842 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3843 data = new wxPyUserData(userData);
3844 wxPyEndBlockThreads(blocked);
3845 }
3846 return new wxSizerItem(window, proportion, flag, border, data);
3847 }
3848 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3849 wxPyUserData* data = NULL;
3850 if ( userData ) {
3851 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3852 data = new wxPyUserData(userData);
3853 wxPyEndBlockThreads(blocked);
3854 }
3855 return new wxSizerItem(width, height, proportion, flag, border, data);
3856 }
3857 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3858 wxPyUserData* data = NULL;
3859 if ( userData ) {
3860 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3861 data = new wxPyUserData(userData);
3862 wxPyEndBlockThreads(blocked);
3863 }
3864 return new wxSizerItem(sizer, proportion, flag, border, data);
3865 }
3866
3867 #include <float.h>
3868
3869
3870 SWIGINTERN int
3871 SWIG_AsVal_float (PyObject * obj, float *val)
3872 {
3873 double v;
3874 int res = SWIG_AsVal_double (obj, &v);
3875 if (SWIG_IsOK(res)) {
3876 if ((v < -FLT_MAX || v > FLT_MAX)) {
3877 return SWIG_OverflowError;
3878 } else {
3879 if (val) *val = static_cast< float >(v);
3880 }
3881 }
3882 return res;
3883 }
3884
3885
3886 SWIGINTERNINLINE PyObject *
3887 SWIG_From_float (float value)
3888 {
3889 return SWIG_From_double (value);
3890 }
3891
3892 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3893 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3894 if (data) {
3895 Py_INCREF(data->m_obj);
3896 return data->m_obj;
3897 } else {
3898 Py_INCREF(Py_None);
3899 return Py_None;
3900 }
3901 }
3902 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3903 wxPyUserData* data = NULL;
3904 if ( userData ) {
3905 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3906 data = new wxPyUserData(userData);
3907 wxPyEndBlockThreads(blocked);
3908 }
3909 self->SetUserData(data);
3910 }
3911
3912 // Figure out the type of the sizer item
3913
3914 struct wxPySizerItemInfo {
3915 wxPySizerItemInfo()
3916 : window(NULL), sizer(NULL), gotSize(false),
3917 size(wxDefaultSize), gotPos(false), pos(-1)
3918 {}
3919
3920 wxWindow* window;
3921 wxSizer* sizer;
3922 bool gotSize;
3923 wxSize size;
3924 bool gotPos;
3925 int pos;
3926 };
3927
3928 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3929
3930 wxPySizerItemInfo info;
3931 wxSize size;
3932 wxSize* sizePtr = &size;
3933
3934 // Find out what the type of the item is
3935 // try wxWindow
3936 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3937 PyErr_Clear();
3938 info.window = NULL;
3939
3940 // try wxSizer
3941 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3942 PyErr_Clear();
3943 info.sizer = NULL;
3944
3945 // try wxSize or (w,h)
3946 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3947 info.size = *sizePtr;
3948 info.gotSize = true;
3949 }
3950
3951 // or a single int
3952 if (checkIdx && PyInt_Check(item)) {
3953 info.pos = PyInt_AsLong(item);
3954 info.gotPos = true;
3955 }
3956 }
3957 }
3958
3959 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3960 // no expected type, figure out what kind of error message to generate
3961 if ( !checkSize && !checkIdx )
3962 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3963 else if ( checkSize && !checkIdx )
3964 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3965 else if ( !checkSize && checkIdx)
3966 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3967 else
3968 // can this one happen?
3969 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3970 }
3971
3972 return info;
3973 }
3974
3975 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3976 if (!self->GetClientObject())
3977 self->SetClientObject(new wxPyOORClientData(_self));
3978 }
3979 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3980
3981 wxPyUserData* data = NULL;
3982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3983 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3984 if ( userData && (info.window || info.sizer || info.gotSize) )
3985 data = new wxPyUserData(userData);
3986 if ( info.sizer )
3987 PyObject_SetAttrString(item,"thisown",Py_False);
3988 wxPyEndBlockThreads(blocked);
3989
3990 // Now call the real Add method if a valid item type was found
3991 if ( info.window )
3992 return self->Add(info.window, proportion, flag, border, data);
3993 else if ( info.sizer )
3994 return self->Add(info.sizer, proportion, flag, border, data);
3995 else if (info.gotSize)
3996 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3997 proportion, flag, border, data);
3998 else
3999 return NULL;
4000 }
4001 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4002
4003 wxPyUserData* data = NULL;
4004 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4005 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4006 if ( userData && (info.window || info.sizer || info.gotSize) )
4007 data = new wxPyUserData(userData);
4008 if ( info.sizer )
4009 PyObject_SetAttrString(item,"thisown",Py_False);
4010 wxPyEndBlockThreads(blocked);
4011
4012 // Now call the real Insert method if a valid item type was found
4013 if ( info.window )
4014 return self->Insert(before, info.window, proportion, flag, border, data);
4015 else if ( info.sizer )
4016 return self->Insert(before, info.sizer, proportion, flag, border, data);
4017 else if (info.gotSize)
4018 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4019 proportion, flag, border, data);
4020 else
4021 return NULL;
4022 }
4023 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4024
4025 wxPyUserData* data = NULL;
4026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4027 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4028 if ( userData && (info.window || info.sizer || info.gotSize) )
4029 data = new wxPyUserData(userData);
4030 if ( info.sizer )
4031 PyObject_SetAttrString(item,"thisown",Py_False);
4032 wxPyEndBlockThreads(blocked);
4033
4034 // Now call the real Prepend method if a valid item type was found
4035 if ( info.window )
4036 return self->Prepend(info.window, proportion, flag, border, data);
4037 else if ( info.sizer )
4038 return self->Prepend(info.sizer, proportion, flag, border, data);
4039 else if (info.gotSize)
4040 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4041 proportion, flag, border, data);
4042 else
4043 return NULL;
4044 }
4045 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4047 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4048 wxPyEndBlockThreads(blocked);
4049 if ( info.window )
4050 return self->Remove(info.window);
4051 else if ( info.sizer )
4052 return self->Remove(info.sizer);
4053 else if ( info.gotPos )
4054 return self->Remove(info.pos);
4055 else
4056 return false;
4057 }
4058 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4059 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4060 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4061 wxPyEndBlockThreads(blocked);
4062 if ( info.window )
4063 return self->Detach(info.window);
4064 else if ( info.sizer )
4065 return self->Detach(info.sizer);
4066 else if ( info.gotPos )
4067 return self->Detach(info.pos);
4068 else
4069 return false;
4070 }
4071 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4072 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4073 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4074 wxPyEndBlockThreads(blocked);
4075 if ( info.window )
4076 return self->GetItem(info.window);
4077 else if ( info.sizer )
4078 return self->GetItem(info.sizer);
4079 else if ( info.gotPos )
4080 return self->GetItem(info.pos);
4081 else
4082 return NULL;
4083 }
4084 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4085 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4086 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4087 wxPyEndBlockThreads(blocked);
4088 if ( info.window )
4089 self->SetItemMinSize(info.window, size);
4090 else if ( info.sizer )
4091 self->SetItemMinSize(info.sizer, size);
4092 else if ( info.gotPos )
4093 self->SetItemMinSize(info.pos, size);
4094 }
4095 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4096 wxSizerItemList& list = self->GetChildren();
4097 return wxPy_ConvertList(&list);
4098 }
4099 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4100 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4101 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4102 wxPyEndBlockThreads(blocked);
4103 if ( info.window )
4104 return self->Show(info.window, show, recursive);
4105 else if ( info.sizer )
4106 return self->Show(info.sizer, show, recursive);
4107 else if ( info.gotPos )
4108 return self->Show(info.pos, show);
4109 else
4110 return false;
4111 }
4112 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4113 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4114 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4115 wxPyEndBlockThreads(blocked);
4116 if ( info.window )
4117 return self->IsShown(info.window);
4118 else if ( info.sizer )
4119 return self->IsShown(info.sizer);
4120 else if ( info.gotPos )
4121 return self->IsShown(info.pos);
4122 else
4123 return false;
4124 }
4125
4126 // See pyclasses.h
4127 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4128 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4129 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4130
4131
4132
4133
4134 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4135 {
4136 if (source == Py_None) {
4137 **obj = wxGBPosition(-1,-1);
4138 return true;
4139 }
4140 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4141 }
4142
4143 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4144 {
4145 if (source == Py_None) {
4146 **obj = wxGBSpan(-1,-1);
4147 return true;
4148 }
4149 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4150 }
4151
4152
4153 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4154 self->SetRow(row);
4155 self->SetCol(col);
4156 }
4157 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4158 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4159 PyObject* tup = PyTuple_New(2);
4160 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4161 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4162 wxPyEndBlockThreads(blocked);
4163 return tup;
4164 }
4165 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4166 self->SetRowspan(rowspan);
4167 self->SetColspan(colspan);
4168 }
4169 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4171 PyObject* tup = PyTuple_New(2);
4172 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4173 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4174 wxPyEndBlockThreads(blocked);
4175 return tup;
4176 }
4177 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4178 wxPyUserData* data = NULL;
4179 if ( userData ) {
4180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4181 data = new wxPyUserData(userData);
4182 wxPyEndBlockThreads(blocked);
4183 }
4184 return new wxGBSizerItem(window, pos, span, flag, border, data);
4185 }
4186 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4187 wxPyUserData* data = NULL;
4188 if ( userData ) {
4189 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4190 data = new wxPyUserData(userData);
4191 wxPyEndBlockThreads(blocked);
4192 }
4193 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4194 }
4195 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4196 wxPyUserData* data = NULL;
4197 if ( userData ) {
4198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4199 data = new wxPyUserData(userData);
4200 wxPyEndBlockThreads(blocked);
4201 }
4202 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4203 }
4204 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4205 int row, col;
4206 self->GetEndPos(row, col);
4207 return wxGBPosition(row, col);
4208 }
4209 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4210
4211 wxPyUserData* data = NULL;
4212 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4213 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4214 if ( userData && (info.window || info.sizer || info.gotSize) )
4215 data = new wxPyUserData(userData);
4216 if ( info.sizer )
4217 PyObject_SetAttrString(item,"thisown",Py_False);
4218 wxPyEndBlockThreads(blocked);
4219
4220 // Now call the real Add method if a valid item type was found
4221 if ( info.window )
4222 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4223 else if ( info.sizer )
4224 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4225 else if (info.gotSize)
4226 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4227 pos, span, flag, border, data);
4228 return NULL;
4229 }
4230
4231
4232 #ifdef __cplusplus
4233 extern "C" {
4234 #endif
4235 SWIGINTERN int EmptyString_set(PyObject *) {
4236 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4237 return 1;
4238 }
4239
4240
4241 SWIGINTERN PyObject *EmptyString_get(void) {
4242 PyObject *pyobj = 0;
4243
4244 {
4245 #if wxUSE_UNICODE
4246 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4247 #else
4248 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4249 #endif
4250 }
4251 return pyobj;
4252 }
4253
4254
4255 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4256 PyObject *resultobj = 0;
4257 wxObject *arg1 = (wxObject *) 0 ;
4258 wxString result;
4259 void *argp1 = 0 ;
4260 int res1 = 0 ;
4261 PyObject *swig_obj[1] ;
4262
4263 if (!args) SWIG_fail;
4264 swig_obj[0] = args;
4265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4266 if (!SWIG_IsOK(res1)) {
4267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4268 }
4269 arg1 = reinterpret_cast< wxObject * >(argp1);
4270 {
4271 PyThreadState* __tstate = wxPyBeginAllowThreads();
4272 result = wxObject_GetClassName(arg1);
4273 wxPyEndAllowThreads(__tstate);
4274 if (PyErr_Occurred()) SWIG_fail;
4275 }
4276 {
4277 #if wxUSE_UNICODE
4278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4279 #else
4280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4281 #endif
4282 }
4283 return resultobj;
4284 fail:
4285 return NULL;
4286 }
4287
4288
4289 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4290 PyObject *resultobj = 0;
4291 wxObject *arg1 = (wxObject *) 0 ;
4292 void *argp1 = 0 ;
4293 int res1 = 0 ;
4294 PyObject *swig_obj[1] ;
4295
4296 if (!args) SWIG_fail;
4297 swig_obj[0] = args;
4298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4299 if (!SWIG_IsOK(res1)) {
4300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4301 }
4302 arg1 = reinterpret_cast< wxObject * >(argp1);
4303 {
4304 PyThreadState* __tstate = wxPyBeginAllowThreads();
4305 wxObject_Destroy(arg1);
4306 wxPyEndAllowThreads(__tstate);
4307 if (PyErr_Occurred()) SWIG_fail;
4308 }
4309 resultobj = SWIG_Py_Void();
4310 return resultobj;
4311 fail:
4312 return NULL;
4313 }
4314
4315
4316 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4317 PyObject *obj;
4318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4319 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4320 return SWIG_Py_Void();
4321 }
4322
4323 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4324 PyObject *resultobj = 0;
4325 wxSize *arg1 = (wxSize *) 0 ;
4326 int arg2 ;
4327 void *argp1 = 0 ;
4328 int res1 = 0 ;
4329 int val2 ;
4330 int ecode2 = 0 ;
4331 PyObject *swig_obj[2] ;
4332
4333 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4335 if (!SWIG_IsOK(res1)) {
4336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4337 }
4338 arg1 = reinterpret_cast< wxSize * >(argp1);
4339 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4340 if (!SWIG_IsOK(ecode2)) {
4341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4342 }
4343 arg2 = static_cast< int >(val2);
4344 if (arg1) (arg1)->x = arg2;
4345
4346 resultobj = SWIG_Py_Void();
4347 return resultobj;
4348 fail:
4349 return NULL;
4350 }
4351
4352
4353 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4354 PyObject *resultobj = 0;
4355 wxSize *arg1 = (wxSize *) 0 ;
4356 int result;
4357 void *argp1 = 0 ;
4358 int res1 = 0 ;
4359 PyObject *swig_obj[1] ;
4360
4361 if (!args) SWIG_fail;
4362 swig_obj[0] = args;
4363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4364 if (!SWIG_IsOK(res1)) {
4365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4366 }
4367 arg1 = reinterpret_cast< wxSize * >(argp1);
4368 result = (int) ((arg1)->x);
4369 resultobj = SWIG_From_int(static_cast< int >(result));
4370 return resultobj;
4371 fail:
4372 return NULL;
4373 }
4374
4375
4376 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4377 PyObject *resultobj = 0;
4378 wxSize *arg1 = (wxSize *) 0 ;
4379 int arg2 ;
4380 void *argp1 = 0 ;
4381 int res1 = 0 ;
4382 int val2 ;
4383 int ecode2 = 0 ;
4384 PyObject *swig_obj[2] ;
4385
4386 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4388 if (!SWIG_IsOK(res1)) {
4389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4390 }
4391 arg1 = reinterpret_cast< wxSize * >(argp1);
4392 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4393 if (!SWIG_IsOK(ecode2)) {
4394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4395 }
4396 arg2 = static_cast< int >(val2);
4397 if (arg1) (arg1)->y = arg2;
4398
4399 resultobj = SWIG_Py_Void();
4400 return resultobj;
4401 fail:
4402 return NULL;
4403 }
4404
4405
4406 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4407 PyObject *resultobj = 0;
4408 wxSize *arg1 = (wxSize *) 0 ;
4409 int result;
4410 void *argp1 = 0 ;
4411 int res1 = 0 ;
4412 PyObject *swig_obj[1] ;
4413
4414 if (!args) SWIG_fail;
4415 swig_obj[0] = args;
4416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4417 if (!SWIG_IsOK(res1)) {
4418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4419 }
4420 arg1 = reinterpret_cast< wxSize * >(argp1);
4421 result = (int) ((arg1)->y);
4422 resultobj = SWIG_From_int(static_cast< int >(result));
4423 return resultobj;
4424 fail:
4425 return NULL;
4426 }
4427
4428
4429 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4430 PyObject *resultobj = 0;
4431 int arg1 = (int) 0 ;
4432 int arg2 = (int) 0 ;
4433 wxSize *result = 0 ;
4434 int val1 ;
4435 int ecode1 = 0 ;
4436 int val2 ;
4437 int ecode2 = 0 ;
4438 PyObject * obj0 = 0 ;
4439 PyObject * obj1 = 0 ;
4440 char * kwnames[] = {
4441 (char *) "w",(char *) "h", NULL
4442 };
4443
4444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4445 if (obj0) {
4446 ecode1 = SWIG_AsVal_int(obj0, &val1);
4447 if (!SWIG_IsOK(ecode1)) {
4448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4449 }
4450 arg1 = static_cast< int >(val1);
4451 }
4452 if (obj1) {
4453 ecode2 = SWIG_AsVal_int(obj1, &val2);
4454 if (!SWIG_IsOK(ecode2)) {
4455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4456 }
4457 arg2 = static_cast< int >(val2);
4458 }
4459 {
4460 PyThreadState* __tstate = wxPyBeginAllowThreads();
4461 result = (wxSize *)new wxSize(arg1,arg2);
4462 wxPyEndAllowThreads(__tstate);
4463 if (PyErr_Occurred()) SWIG_fail;
4464 }
4465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4466 return resultobj;
4467 fail:
4468 return NULL;
4469 }
4470
4471
4472 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4473 PyObject *resultobj = 0;
4474 wxSize *arg1 = (wxSize *) 0 ;
4475 void *argp1 = 0 ;
4476 int res1 = 0 ;
4477 PyObject *swig_obj[1] ;
4478
4479 if (!args) SWIG_fail;
4480 swig_obj[0] = args;
4481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4482 if (!SWIG_IsOK(res1)) {
4483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4484 }
4485 arg1 = reinterpret_cast< wxSize * >(argp1);
4486 {
4487 PyThreadState* __tstate = wxPyBeginAllowThreads();
4488 delete arg1;
4489
4490 wxPyEndAllowThreads(__tstate);
4491 if (PyErr_Occurred()) SWIG_fail;
4492 }
4493 resultobj = SWIG_Py_Void();
4494 return resultobj;
4495 fail:
4496 return NULL;
4497 }
4498
4499
4500 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4501 PyObject *resultobj = 0;
4502 wxSize *arg1 = (wxSize *) 0 ;
4503 wxSize *arg2 = 0 ;
4504 bool result;
4505 void *argp1 = 0 ;
4506 int res1 = 0 ;
4507 wxSize temp2 ;
4508 PyObject * obj0 = 0 ;
4509 PyObject * obj1 = 0 ;
4510 char * kwnames[] = {
4511 (char *) "self",(char *) "sz", NULL
4512 };
4513
4514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4516 if (!SWIG_IsOK(res1)) {
4517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4518 }
4519 arg1 = reinterpret_cast< wxSize * >(argp1);
4520 {
4521 arg2 = &temp2;
4522 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4523 }
4524 {
4525 PyThreadState* __tstate = wxPyBeginAllowThreads();
4526 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
4527 wxPyEndAllowThreads(__tstate);
4528 if (PyErr_Occurred()) SWIG_fail;
4529 }
4530 {
4531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4532 }
4533 return resultobj;
4534 fail:
4535 return NULL;
4536 }
4537
4538
4539 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4540 PyObject *resultobj = 0;
4541 wxSize *arg1 = (wxSize *) 0 ;
4542 wxSize *arg2 = 0 ;
4543 bool result;
4544 void *argp1 = 0 ;
4545 int res1 = 0 ;
4546 wxSize temp2 ;
4547 PyObject * obj0 = 0 ;
4548 PyObject * obj1 = 0 ;
4549 char * kwnames[] = {
4550 (char *) "self",(char *) "sz", NULL
4551 };
4552
4553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4555 if (!SWIG_IsOK(res1)) {
4556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4557 }
4558 arg1 = reinterpret_cast< wxSize * >(argp1);
4559 {
4560 arg2 = &temp2;
4561 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4562 }
4563 {
4564 PyThreadState* __tstate = wxPyBeginAllowThreads();
4565 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
4566 wxPyEndAllowThreads(__tstate);
4567 if (PyErr_Occurred()) SWIG_fail;
4568 }
4569 {
4570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4571 }
4572 return resultobj;
4573 fail:
4574 return NULL;
4575 }
4576
4577
4578 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4579 PyObject *resultobj = 0;
4580 wxSize *arg1 = (wxSize *) 0 ;
4581 wxSize *arg2 = 0 ;
4582 wxSize result;
4583 void *argp1 = 0 ;
4584 int res1 = 0 ;
4585 wxSize temp2 ;
4586 PyObject * obj0 = 0 ;
4587 PyObject * obj1 = 0 ;
4588 char * kwnames[] = {
4589 (char *) "self",(char *) "sz", NULL
4590 };
4591
4592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4594 if (!SWIG_IsOK(res1)) {
4595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4596 }
4597 arg1 = reinterpret_cast< wxSize * >(argp1);
4598 {
4599 arg2 = &temp2;
4600 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4601 }
4602 {
4603 PyThreadState* __tstate = wxPyBeginAllowThreads();
4604 result = (arg1)->operator +((wxSize const &)*arg2);
4605 wxPyEndAllowThreads(__tstate);
4606 if (PyErr_Occurred()) SWIG_fail;
4607 }
4608 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4609 return resultobj;
4610 fail:
4611 return NULL;
4612 }
4613
4614
4615 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4616 PyObject *resultobj = 0;
4617 wxSize *arg1 = (wxSize *) 0 ;
4618 wxSize *arg2 = 0 ;
4619 wxSize result;
4620 void *argp1 = 0 ;
4621 int res1 = 0 ;
4622 wxSize temp2 ;
4623 PyObject * obj0 = 0 ;
4624 PyObject * obj1 = 0 ;
4625 char * kwnames[] = {
4626 (char *) "self",(char *) "sz", NULL
4627 };
4628
4629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4631 if (!SWIG_IsOK(res1)) {
4632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4633 }
4634 arg1 = reinterpret_cast< wxSize * >(argp1);
4635 {
4636 arg2 = &temp2;
4637 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4638 }
4639 {
4640 PyThreadState* __tstate = wxPyBeginAllowThreads();
4641 result = (arg1)->operator -((wxSize const &)*arg2);
4642 wxPyEndAllowThreads(__tstate);
4643 if (PyErr_Occurred()) SWIG_fail;
4644 }
4645 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4646 return resultobj;
4647 fail:
4648 return NULL;
4649 }
4650
4651
4652 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4653 PyObject *resultobj = 0;
4654 wxSize *arg1 = (wxSize *) 0 ;
4655 wxSize *arg2 = 0 ;
4656 void *argp1 = 0 ;
4657 int res1 = 0 ;
4658 wxSize temp2 ;
4659 PyObject * obj0 = 0 ;
4660 PyObject * obj1 = 0 ;
4661 char * kwnames[] = {
4662 (char *) "self",(char *) "sz", NULL
4663 };
4664
4665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4667 if (!SWIG_IsOK(res1)) {
4668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4669 }
4670 arg1 = reinterpret_cast< wxSize * >(argp1);
4671 {
4672 arg2 = &temp2;
4673 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4674 }
4675 {
4676 PyThreadState* __tstate = wxPyBeginAllowThreads();
4677 (arg1)->IncTo((wxSize const &)*arg2);
4678 wxPyEndAllowThreads(__tstate);
4679 if (PyErr_Occurred()) SWIG_fail;
4680 }
4681 resultobj = SWIG_Py_Void();
4682 return resultobj;
4683 fail:
4684 return NULL;
4685 }
4686
4687
4688 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4689 PyObject *resultobj = 0;
4690 wxSize *arg1 = (wxSize *) 0 ;
4691 wxSize *arg2 = 0 ;
4692 void *argp1 = 0 ;
4693 int res1 = 0 ;
4694 wxSize temp2 ;
4695 PyObject * obj0 = 0 ;
4696 PyObject * obj1 = 0 ;
4697 char * kwnames[] = {
4698 (char *) "self",(char *) "sz", NULL
4699 };
4700
4701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4703 if (!SWIG_IsOK(res1)) {
4704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4705 }
4706 arg1 = reinterpret_cast< wxSize * >(argp1);
4707 {
4708 arg2 = &temp2;
4709 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4710 }
4711 {
4712 PyThreadState* __tstate = wxPyBeginAllowThreads();
4713 (arg1)->DecTo((wxSize const &)*arg2);
4714 wxPyEndAllowThreads(__tstate);
4715 if (PyErr_Occurred()) SWIG_fail;
4716 }
4717 resultobj = SWIG_Py_Void();
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj = 0;
4726 wxSize *arg1 = (wxSize *) 0 ;
4727 int arg2 ;
4728 int arg3 ;
4729 void *argp1 = 0 ;
4730 int res1 = 0 ;
4731 int val2 ;
4732 int ecode2 = 0 ;
4733 int val3 ;
4734 int ecode3 = 0 ;
4735 PyObject * obj0 = 0 ;
4736 PyObject * obj1 = 0 ;
4737 PyObject * obj2 = 0 ;
4738 char * kwnames[] = {
4739 (char *) "self",(char *) "w",(char *) "h", NULL
4740 };
4741
4742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4744 if (!SWIG_IsOK(res1)) {
4745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4746 }
4747 arg1 = reinterpret_cast< wxSize * >(argp1);
4748 ecode2 = SWIG_AsVal_int(obj1, &val2);
4749 if (!SWIG_IsOK(ecode2)) {
4750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4751 }
4752 arg2 = static_cast< int >(val2);
4753 ecode3 = SWIG_AsVal_int(obj2, &val3);
4754 if (!SWIG_IsOK(ecode3)) {
4755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4756 }
4757 arg3 = static_cast< int >(val3);
4758 {
4759 PyThreadState* __tstate = wxPyBeginAllowThreads();
4760 (arg1)->Set(arg2,arg3);
4761 wxPyEndAllowThreads(__tstate);
4762 if (PyErr_Occurred()) SWIG_fail;
4763 }
4764 resultobj = SWIG_Py_Void();
4765 return resultobj;
4766 fail:
4767 return NULL;
4768 }
4769
4770
4771 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4772 PyObject *resultobj = 0;
4773 wxSize *arg1 = (wxSize *) 0 ;
4774 int arg2 ;
4775 void *argp1 = 0 ;
4776 int res1 = 0 ;
4777 int val2 ;
4778 int ecode2 = 0 ;
4779 PyObject * obj0 = 0 ;
4780 PyObject * obj1 = 0 ;
4781 char * kwnames[] = {
4782 (char *) "self",(char *) "w", NULL
4783 };
4784
4785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4787 if (!SWIG_IsOK(res1)) {
4788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4789 }
4790 arg1 = reinterpret_cast< wxSize * >(argp1);
4791 ecode2 = SWIG_AsVal_int(obj1, &val2);
4792 if (!SWIG_IsOK(ecode2)) {
4793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4794 }
4795 arg2 = static_cast< int >(val2);
4796 {
4797 PyThreadState* __tstate = wxPyBeginAllowThreads();
4798 (arg1)->SetWidth(arg2);
4799 wxPyEndAllowThreads(__tstate);
4800 if (PyErr_Occurred()) SWIG_fail;
4801 }
4802 resultobj = SWIG_Py_Void();
4803 return resultobj;
4804 fail:
4805 return NULL;
4806 }
4807
4808
4809 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4810 PyObject *resultobj = 0;
4811 wxSize *arg1 = (wxSize *) 0 ;
4812 int arg2 ;
4813 void *argp1 = 0 ;
4814 int res1 = 0 ;
4815 int val2 ;
4816 int ecode2 = 0 ;
4817 PyObject * obj0 = 0 ;
4818 PyObject * obj1 = 0 ;
4819 char * kwnames[] = {
4820 (char *) "self",(char *) "h", NULL
4821 };
4822
4823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4825 if (!SWIG_IsOK(res1)) {
4826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4827 }
4828 arg1 = reinterpret_cast< wxSize * >(argp1);
4829 ecode2 = SWIG_AsVal_int(obj1, &val2);
4830 if (!SWIG_IsOK(ecode2)) {
4831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4832 }
4833 arg2 = static_cast< int >(val2);
4834 {
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 (arg1)->SetHeight(arg2);
4837 wxPyEndAllowThreads(__tstate);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 resultobj = SWIG_Py_Void();
4841 return resultobj;
4842 fail:
4843 return NULL;
4844 }
4845
4846
4847 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4848 PyObject *resultobj = 0;
4849 wxSize *arg1 = (wxSize *) 0 ;
4850 int result;
4851 void *argp1 = 0 ;
4852 int res1 = 0 ;
4853 PyObject *swig_obj[1] ;
4854
4855 if (!args) SWIG_fail;
4856 swig_obj[0] = args;
4857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4858 if (!SWIG_IsOK(res1)) {
4859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4860 }
4861 arg1 = reinterpret_cast< wxSize * >(argp1);
4862 {
4863 PyThreadState* __tstate = wxPyBeginAllowThreads();
4864 result = (int)((wxSize const *)arg1)->GetWidth();
4865 wxPyEndAllowThreads(__tstate);
4866 if (PyErr_Occurred()) SWIG_fail;
4867 }
4868 resultobj = SWIG_From_int(static_cast< int >(result));
4869 return resultobj;
4870 fail:
4871 return NULL;
4872 }
4873
4874
4875 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4876 PyObject *resultobj = 0;
4877 wxSize *arg1 = (wxSize *) 0 ;
4878 int result;
4879 void *argp1 = 0 ;
4880 int res1 = 0 ;
4881 PyObject *swig_obj[1] ;
4882
4883 if (!args) SWIG_fail;
4884 swig_obj[0] = args;
4885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4886 if (!SWIG_IsOK(res1)) {
4887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4888 }
4889 arg1 = reinterpret_cast< wxSize * >(argp1);
4890 {
4891 PyThreadState* __tstate = wxPyBeginAllowThreads();
4892 result = (int)((wxSize const *)arg1)->GetHeight();
4893 wxPyEndAllowThreads(__tstate);
4894 if (PyErr_Occurred()) SWIG_fail;
4895 }
4896 resultobj = SWIG_From_int(static_cast< int >(result));
4897 return resultobj;
4898 fail:
4899 return NULL;
4900 }
4901
4902
4903 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4904 PyObject *resultobj = 0;
4905 wxSize *arg1 = (wxSize *) 0 ;
4906 bool result;
4907 void *argp1 = 0 ;
4908 int res1 = 0 ;
4909 PyObject *swig_obj[1] ;
4910
4911 if (!args) SWIG_fail;
4912 swig_obj[0] = args;
4913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4914 if (!SWIG_IsOK(res1)) {
4915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
4916 }
4917 arg1 = reinterpret_cast< wxSize * >(argp1);
4918 {
4919 PyThreadState* __tstate = wxPyBeginAllowThreads();
4920 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4921 wxPyEndAllowThreads(__tstate);
4922 if (PyErr_Occurred()) SWIG_fail;
4923 }
4924 {
4925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4926 }
4927 return resultobj;
4928 fail:
4929 return NULL;
4930 }
4931
4932
4933 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4934 PyObject *resultobj = 0;
4935 wxSize *arg1 = (wxSize *) 0 ;
4936 wxSize *arg2 = 0 ;
4937 void *argp1 = 0 ;
4938 int res1 = 0 ;
4939 wxSize temp2 ;
4940 PyObject * obj0 = 0 ;
4941 PyObject * obj1 = 0 ;
4942 char * kwnames[] = {
4943 (char *) "self",(char *) "size", NULL
4944 };
4945
4946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
4947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4948 if (!SWIG_IsOK(res1)) {
4949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
4950 }
4951 arg1 = reinterpret_cast< wxSize * >(argp1);
4952 {
4953 arg2 = &temp2;
4954 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4955 }
4956 {
4957 PyThreadState* __tstate = wxPyBeginAllowThreads();
4958 (arg1)->SetDefaults((wxSize const &)*arg2);
4959 wxPyEndAllowThreads(__tstate);
4960 if (PyErr_Occurred()) SWIG_fail;
4961 }
4962 resultobj = SWIG_Py_Void();
4963 return resultobj;
4964 fail:
4965 return NULL;
4966 }
4967
4968
4969 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4970 PyObject *resultobj = 0;
4971 wxSize *arg1 = (wxSize *) 0 ;
4972 PyObject *result = 0 ;
4973 void *argp1 = 0 ;
4974 int res1 = 0 ;
4975 PyObject *swig_obj[1] ;
4976
4977 if (!args) SWIG_fail;
4978 swig_obj[0] = args;
4979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4980 if (!SWIG_IsOK(res1)) {
4981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
4982 }
4983 arg1 = reinterpret_cast< wxSize * >(argp1);
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 result = (PyObject *)wxSize_Get(arg1);
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 resultobj = result;
4991 return resultobj;
4992 fail:
4993 return NULL;
4994 }
4995
4996
4997 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4998 PyObject *obj;
4999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5000 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5001 return SWIG_Py_Void();
5002 }
5003
5004 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5005 return SWIG_Python_InitShadowInstance(args);
5006 }
5007
5008 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5009 PyObject *resultobj = 0;
5010 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5011 double arg2 ;
5012 void *argp1 = 0 ;
5013 int res1 = 0 ;
5014 double val2 ;
5015 int ecode2 = 0 ;
5016 PyObject *swig_obj[2] ;
5017
5018 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5020 if (!SWIG_IsOK(res1)) {
5021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5022 }
5023 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5024 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5025 if (!SWIG_IsOK(ecode2)) {
5026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5027 }
5028 arg2 = static_cast< double >(val2);
5029 if (arg1) (arg1)->x = arg2;
5030
5031 resultobj = SWIG_Py_Void();
5032 return resultobj;
5033 fail:
5034 return NULL;
5035 }
5036
5037
5038 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5039 PyObject *resultobj = 0;
5040 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5041 double result;
5042 void *argp1 = 0 ;
5043 int res1 = 0 ;
5044 PyObject *swig_obj[1] ;
5045
5046 if (!args) SWIG_fail;
5047 swig_obj[0] = args;
5048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5049 if (!SWIG_IsOK(res1)) {
5050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5051 }
5052 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5053 result = (double) ((arg1)->x);
5054 resultobj = SWIG_From_double(static_cast< double >(result));
5055 return resultobj;
5056 fail:
5057 return NULL;
5058 }
5059
5060
5061 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5062 PyObject *resultobj = 0;
5063 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5064 double arg2 ;
5065 void *argp1 = 0 ;
5066 int res1 = 0 ;
5067 double val2 ;
5068 int ecode2 = 0 ;
5069 PyObject *swig_obj[2] ;
5070
5071 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5073 if (!SWIG_IsOK(res1)) {
5074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5075 }
5076 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5077 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5078 if (!SWIG_IsOK(ecode2)) {
5079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5080 }
5081 arg2 = static_cast< double >(val2);
5082 if (arg1) (arg1)->y = arg2;
5083
5084 resultobj = SWIG_Py_Void();
5085 return resultobj;
5086 fail:
5087 return NULL;
5088 }
5089
5090
5091 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5092 PyObject *resultobj = 0;
5093 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5094 double result;
5095 void *argp1 = 0 ;
5096 int res1 = 0 ;
5097 PyObject *swig_obj[1] ;
5098
5099 if (!args) SWIG_fail;
5100 swig_obj[0] = args;
5101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5102 if (!SWIG_IsOK(res1)) {
5103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5104 }
5105 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5106 result = (double) ((arg1)->y);
5107 resultobj = SWIG_From_double(static_cast< double >(result));
5108 return resultobj;
5109 fail:
5110 return NULL;
5111 }
5112
5113
5114 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5115 PyObject *resultobj = 0;
5116 double arg1 = (double) 0.0 ;
5117 double arg2 = (double) 0.0 ;
5118 wxRealPoint *result = 0 ;
5119 double val1 ;
5120 int ecode1 = 0 ;
5121 double val2 ;
5122 int ecode2 = 0 ;
5123 PyObject * obj0 = 0 ;
5124 PyObject * obj1 = 0 ;
5125 char * kwnames[] = {
5126 (char *) "x",(char *) "y", NULL
5127 };
5128
5129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5130 if (obj0) {
5131 ecode1 = SWIG_AsVal_double(obj0, &val1);
5132 if (!SWIG_IsOK(ecode1)) {
5133 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5134 }
5135 arg1 = static_cast< double >(val1);
5136 }
5137 if (obj1) {
5138 ecode2 = SWIG_AsVal_double(obj1, &val2);
5139 if (!SWIG_IsOK(ecode2)) {
5140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5141 }
5142 arg2 = static_cast< double >(val2);
5143 }
5144 {
5145 PyThreadState* __tstate = wxPyBeginAllowThreads();
5146 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5147 wxPyEndAllowThreads(__tstate);
5148 if (PyErr_Occurred()) SWIG_fail;
5149 }
5150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5151 return resultobj;
5152 fail:
5153 return NULL;
5154 }
5155
5156
5157 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5158 PyObject *resultobj = 0;
5159 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5160 void *argp1 = 0 ;
5161 int res1 = 0 ;
5162 PyObject *swig_obj[1] ;
5163
5164 if (!args) SWIG_fail;
5165 swig_obj[0] = args;
5166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5167 if (!SWIG_IsOK(res1)) {
5168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5169 }
5170 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5171 {
5172 PyThreadState* __tstate = wxPyBeginAllowThreads();
5173 delete arg1;
5174
5175 wxPyEndAllowThreads(__tstate);
5176 if (PyErr_Occurred()) SWIG_fail;
5177 }
5178 resultobj = SWIG_Py_Void();
5179 return resultobj;
5180 fail:
5181 return NULL;
5182 }
5183
5184
5185 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5186 PyObject *resultobj = 0;
5187 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5188 wxRealPoint *arg2 = 0 ;
5189 bool result;
5190 void *argp1 = 0 ;
5191 int res1 = 0 ;
5192 wxRealPoint temp2 ;
5193 PyObject * obj0 = 0 ;
5194 PyObject * obj1 = 0 ;
5195 char * kwnames[] = {
5196 (char *) "self",(char *) "pt", NULL
5197 };
5198
5199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5201 if (!SWIG_IsOK(res1)) {
5202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5203 }
5204 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5205 {
5206 arg2 = &temp2;
5207 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5208 }
5209 {
5210 PyThreadState* __tstate = wxPyBeginAllowThreads();
5211 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
5212 wxPyEndAllowThreads(__tstate);
5213 if (PyErr_Occurred()) SWIG_fail;
5214 }
5215 {
5216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5217 }
5218 return resultobj;
5219 fail:
5220 return NULL;
5221 }
5222
5223
5224 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5225 PyObject *resultobj = 0;
5226 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5227 wxRealPoint *arg2 = 0 ;
5228 bool result;
5229 void *argp1 = 0 ;
5230 int res1 = 0 ;
5231 wxRealPoint temp2 ;
5232 PyObject * obj0 = 0 ;
5233 PyObject * obj1 = 0 ;
5234 char * kwnames[] = {
5235 (char *) "self",(char *) "pt", NULL
5236 };
5237
5238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5240 if (!SWIG_IsOK(res1)) {
5241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5242 }
5243 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5244 {
5245 arg2 = &temp2;
5246 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5247 }
5248 {
5249 PyThreadState* __tstate = wxPyBeginAllowThreads();
5250 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
5251 wxPyEndAllowThreads(__tstate);
5252 if (PyErr_Occurred()) SWIG_fail;
5253 }
5254 {
5255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5256 }
5257 return resultobj;
5258 fail:
5259 return NULL;
5260 }
5261
5262
5263 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5264 PyObject *resultobj = 0;
5265 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5266 wxRealPoint *arg2 = 0 ;
5267 wxRealPoint result;
5268 void *argp1 = 0 ;
5269 int res1 = 0 ;
5270 wxRealPoint temp2 ;
5271 PyObject * obj0 = 0 ;
5272 PyObject * obj1 = 0 ;
5273 char * kwnames[] = {
5274 (char *) "self",(char *) "pt", NULL
5275 };
5276
5277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5279 if (!SWIG_IsOK(res1)) {
5280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5281 }
5282 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5283 {
5284 arg2 = &temp2;
5285 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5286 }
5287 {
5288 PyThreadState* __tstate = wxPyBeginAllowThreads();
5289 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5290 wxPyEndAllowThreads(__tstate);
5291 if (PyErr_Occurred()) SWIG_fail;
5292 }
5293 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5294 return resultobj;
5295 fail:
5296 return NULL;
5297 }
5298
5299
5300 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5301 PyObject *resultobj = 0;
5302 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5303 wxRealPoint *arg2 = 0 ;
5304 wxRealPoint result;
5305 void *argp1 = 0 ;
5306 int res1 = 0 ;
5307 wxRealPoint temp2 ;
5308 PyObject * obj0 = 0 ;
5309 PyObject * obj1 = 0 ;
5310 char * kwnames[] = {
5311 (char *) "self",(char *) "pt", NULL
5312 };
5313
5314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5316 if (!SWIG_IsOK(res1)) {
5317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5318 }
5319 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5320 {
5321 arg2 = &temp2;
5322 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5323 }
5324 {
5325 PyThreadState* __tstate = wxPyBeginAllowThreads();
5326 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5327 wxPyEndAllowThreads(__tstate);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5331 return resultobj;
5332 fail:
5333 return NULL;
5334 }
5335
5336
5337 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5338 PyObject *resultobj = 0;
5339 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5340 double arg2 ;
5341 double arg3 ;
5342 void *argp1 = 0 ;
5343 int res1 = 0 ;
5344 double val2 ;
5345 int ecode2 = 0 ;
5346 double val3 ;
5347 int ecode3 = 0 ;
5348 PyObject * obj0 = 0 ;
5349 PyObject * obj1 = 0 ;
5350 PyObject * obj2 = 0 ;
5351 char * kwnames[] = {
5352 (char *) "self",(char *) "x",(char *) "y", NULL
5353 };
5354
5355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5357 if (!SWIG_IsOK(res1)) {
5358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5359 }
5360 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5361 ecode2 = SWIG_AsVal_double(obj1, &val2);
5362 if (!SWIG_IsOK(ecode2)) {
5363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5364 }
5365 arg2 = static_cast< double >(val2);
5366 ecode3 = SWIG_AsVal_double(obj2, &val3);
5367 if (!SWIG_IsOK(ecode3)) {
5368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5369 }
5370 arg3 = static_cast< double >(val3);
5371 {
5372 PyThreadState* __tstate = wxPyBeginAllowThreads();
5373 wxRealPoint_Set(arg1,arg2,arg3);
5374 wxPyEndAllowThreads(__tstate);
5375 if (PyErr_Occurred()) SWIG_fail;
5376 }
5377 resultobj = SWIG_Py_Void();
5378 return resultobj;
5379 fail:
5380 return NULL;
5381 }
5382
5383
5384 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5385 PyObject *resultobj = 0;
5386 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5387 PyObject *result = 0 ;
5388 void *argp1 = 0 ;
5389 int res1 = 0 ;
5390 PyObject *swig_obj[1] ;
5391
5392 if (!args) SWIG_fail;
5393 swig_obj[0] = args;
5394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5395 if (!SWIG_IsOK(res1)) {
5396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5397 }
5398 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5399 {
5400 PyThreadState* __tstate = wxPyBeginAllowThreads();
5401 result = (PyObject *)wxRealPoint_Get(arg1);
5402 wxPyEndAllowThreads(__tstate);
5403 if (PyErr_Occurred()) SWIG_fail;
5404 }
5405 resultobj = result;
5406 return resultobj;
5407 fail:
5408 return NULL;
5409 }
5410
5411
5412 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5413 PyObject *obj;
5414 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5415 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5416 return SWIG_Py_Void();
5417 }
5418
5419 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5420 return SWIG_Python_InitShadowInstance(args);
5421 }
5422
5423 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5424 PyObject *resultobj = 0;
5425 wxPoint *arg1 = (wxPoint *) 0 ;
5426 int arg2 ;
5427 void *argp1 = 0 ;
5428 int res1 = 0 ;
5429 int val2 ;
5430 int ecode2 = 0 ;
5431 PyObject *swig_obj[2] ;
5432
5433 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5435 if (!SWIG_IsOK(res1)) {
5436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5437 }
5438 arg1 = reinterpret_cast< wxPoint * >(argp1);
5439 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5440 if (!SWIG_IsOK(ecode2)) {
5441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5442 }
5443 arg2 = static_cast< int >(val2);
5444 if (arg1) (arg1)->x = arg2;
5445
5446 resultobj = SWIG_Py_Void();
5447 return resultobj;
5448 fail:
5449 return NULL;
5450 }
5451
5452
5453 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5454 PyObject *resultobj = 0;
5455 wxPoint *arg1 = (wxPoint *) 0 ;
5456 int result;
5457 void *argp1 = 0 ;
5458 int res1 = 0 ;
5459 PyObject *swig_obj[1] ;
5460
5461 if (!args) SWIG_fail;
5462 swig_obj[0] = args;
5463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5464 if (!SWIG_IsOK(res1)) {
5465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5466 }
5467 arg1 = reinterpret_cast< wxPoint * >(argp1);
5468 result = (int) ((arg1)->x);
5469 resultobj = SWIG_From_int(static_cast< int >(result));
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5477 PyObject *resultobj = 0;
5478 wxPoint *arg1 = (wxPoint *) 0 ;
5479 int arg2 ;
5480 void *argp1 = 0 ;
5481 int res1 = 0 ;
5482 int val2 ;
5483 int ecode2 = 0 ;
5484 PyObject *swig_obj[2] ;
5485
5486 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5488 if (!SWIG_IsOK(res1)) {
5489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5490 }
5491 arg1 = reinterpret_cast< wxPoint * >(argp1);
5492 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5493 if (!SWIG_IsOK(ecode2)) {
5494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5495 }
5496 arg2 = static_cast< int >(val2);
5497 if (arg1) (arg1)->y = arg2;
5498
5499 resultobj = SWIG_Py_Void();
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5507 PyObject *resultobj = 0;
5508 wxPoint *arg1 = (wxPoint *) 0 ;
5509 int result;
5510 void *argp1 = 0 ;
5511 int res1 = 0 ;
5512 PyObject *swig_obj[1] ;
5513
5514 if (!args) SWIG_fail;
5515 swig_obj[0] = args;
5516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5517 if (!SWIG_IsOK(res1)) {
5518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5519 }
5520 arg1 = reinterpret_cast< wxPoint * >(argp1);
5521 result = (int) ((arg1)->y);
5522 resultobj = SWIG_From_int(static_cast< int >(result));
5523 return resultobj;
5524 fail:
5525 return NULL;
5526 }
5527
5528
5529 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5530 PyObject *resultobj = 0;
5531 int arg1 = (int) 0 ;
5532 int arg2 = (int) 0 ;
5533 wxPoint *result = 0 ;
5534 int val1 ;
5535 int ecode1 = 0 ;
5536 int val2 ;
5537 int ecode2 = 0 ;
5538 PyObject * obj0 = 0 ;
5539 PyObject * obj1 = 0 ;
5540 char * kwnames[] = {
5541 (char *) "x",(char *) "y", NULL
5542 };
5543
5544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5545 if (obj0) {
5546 ecode1 = SWIG_AsVal_int(obj0, &val1);
5547 if (!SWIG_IsOK(ecode1)) {
5548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5549 }
5550 arg1 = static_cast< int >(val1);
5551 }
5552 if (obj1) {
5553 ecode2 = SWIG_AsVal_int(obj1, &val2);
5554 if (!SWIG_IsOK(ecode2)) {
5555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5556 }
5557 arg2 = static_cast< int >(val2);
5558 }
5559 {
5560 PyThreadState* __tstate = wxPyBeginAllowThreads();
5561 result = (wxPoint *)new wxPoint(arg1,arg2);
5562 wxPyEndAllowThreads(__tstate);
5563 if (PyErr_Occurred()) SWIG_fail;
5564 }
5565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5566 return resultobj;
5567 fail:
5568 return NULL;
5569 }
5570
5571
5572 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5573 PyObject *resultobj = 0;
5574 wxPoint *arg1 = (wxPoint *) 0 ;
5575 void *argp1 = 0 ;
5576 int res1 = 0 ;
5577 PyObject *swig_obj[1] ;
5578
5579 if (!args) SWIG_fail;
5580 swig_obj[0] = args;
5581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5582 if (!SWIG_IsOK(res1)) {
5583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5584 }
5585 arg1 = reinterpret_cast< wxPoint * >(argp1);
5586 {
5587 PyThreadState* __tstate = wxPyBeginAllowThreads();
5588 delete arg1;
5589
5590 wxPyEndAllowThreads(__tstate);
5591 if (PyErr_Occurred()) SWIG_fail;
5592 }
5593 resultobj = SWIG_Py_Void();
5594 return resultobj;
5595 fail:
5596 return NULL;
5597 }
5598
5599
5600 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5601 PyObject *resultobj = 0;
5602 wxPoint *arg1 = (wxPoint *) 0 ;
5603 wxPoint *arg2 = 0 ;
5604 bool result;
5605 void *argp1 = 0 ;
5606 int res1 = 0 ;
5607 wxPoint temp2 ;
5608 PyObject * obj0 = 0 ;
5609 PyObject * obj1 = 0 ;
5610 char * kwnames[] = {
5611 (char *) "self",(char *) "pt", NULL
5612 };
5613
5614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5616 if (!SWIG_IsOK(res1)) {
5617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5618 }
5619 arg1 = reinterpret_cast< wxPoint * >(argp1);
5620 {
5621 arg2 = &temp2;
5622 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5623 }
5624 {
5625 PyThreadState* __tstate = wxPyBeginAllowThreads();
5626 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
5627 wxPyEndAllowThreads(__tstate);
5628 if (PyErr_Occurred()) SWIG_fail;
5629 }
5630 {
5631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5632 }
5633 return resultobj;
5634 fail:
5635 return NULL;
5636 }
5637
5638
5639 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5640 PyObject *resultobj = 0;
5641 wxPoint *arg1 = (wxPoint *) 0 ;
5642 wxPoint *arg2 = 0 ;
5643 bool result;
5644 void *argp1 = 0 ;
5645 int res1 = 0 ;
5646 wxPoint temp2 ;
5647 PyObject * obj0 = 0 ;
5648 PyObject * obj1 = 0 ;
5649 char * kwnames[] = {
5650 (char *) "self",(char *) "pt", NULL
5651 };
5652
5653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5655 if (!SWIG_IsOK(res1)) {
5656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5657 }
5658 arg1 = reinterpret_cast< wxPoint * >(argp1);
5659 {
5660 arg2 = &temp2;
5661 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5662 }
5663 {
5664 PyThreadState* __tstate = wxPyBeginAllowThreads();
5665 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
5666 wxPyEndAllowThreads(__tstate);
5667 if (PyErr_Occurred()) SWIG_fail;
5668 }
5669 {
5670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5671 }
5672 return resultobj;
5673 fail:
5674 return NULL;
5675 }
5676
5677
5678 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5679 PyObject *resultobj = 0;
5680 wxPoint *arg1 = (wxPoint *) 0 ;
5681 wxPoint *arg2 = 0 ;
5682 wxPoint result;
5683 void *argp1 = 0 ;
5684 int res1 = 0 ;
5685 wxPoint temp2 ;
5686 PyObject * obj0 = 0 ;
5687 PyObject * obj1 = 0 ;
5688 char * kwnames[] = {
5689 (char *) "self",(char *) "pt", NULL
5690 };
5691
5692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5694 if (!SWIG_IsOK(res1)) {
5695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5696 }
5697 arg1 = reinterpret_cast< wxPoint * >(argp1);
5698 {
5699 arg2 = &temp2;
5700 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5701 }
5702 {
5703 PyThreadState* __tstate = wxPyBeginAllowThreads();
5704 result = (arg1)->operator +((wxPoint const &)*arg2);
5705 wxPyEndAllowThreads(__tstate);
5706 if (PyErr_Occurred()) SWIG_fail;
5707 }
5708 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5709 return resultobj;
5710 fail:
5711 return NULL;
5712 }
5713
5714
5715 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5716 PyObject *resultobj = 0;
5717 wxPoint *arg1 = (wxPoint *) 0 ;
5718 wxPoint *arg2 = 0 ;
5719 wxPoint result;
5720 void *argp1 = 0 ;
5721 int res1 = 0 ;
5722 wxPoint temp2 ;
5723 PyObject * obj0 = 0 ;
5724 PyObject * obj1 = 0 ;
5725 char * kwnames[] = {
5726 (char *) "self",(char *) "pt", NULL
5727 };
5728
5729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5731 if (!SWIG_IsOK(res1)) {
5732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5733 }
5734 arg1 = reinterpret_cast< wxPoint * >(argp1);
5735 {
5736 arg2 = &temp2;
5737 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5738 }
5739 {
5740 PyThreadState* __tstate = wxPyBeginAllowThreads();
5741 result = (arg1)->operator -((wxPoint const &)*arg2);
5742 wxPyEndAllowThreads(__tstate);
5743 if (PyErr_Occurred()) SWIG_fail;
5744 }
5745 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5753 PyObject *resultobj = 0;
5754 wxPoint *arg1 = (wxPoint *) 0 ;
5755 wxPoint *arg2 = 0 ;
5756 wxPoint *result = 0 ;
5757 void *argp1 = 0 ;
5758 int res1 = 0 ;
5759 wxPoint temp2 ;
5760 PyObject * obj0 = 0 ;
5761 PyObject * obj1 = 0 ;
5762 char * kwnames[] = {
5763 (char *) "self",(char *) "pt", NULL
5764 };
5765
5766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5768 if (!SWIG_IsOK(res1)) {
5769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5770 }
5771 arg1 = reinterpret_cast< wxPoint * >(argp1);
5772 {
5773 arg2 = &temp2;
5774 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5775 }
5776 {
5777 PyThreadState* __tstate = wxPyBeginAllowThreads();
5778 {
5779 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5780 result = (wxPoint *) &_result_ref;
5781 }
5782 wxPyEndAllowThreads(__tstate);
5783 if (PyErr_Occurred()) SWIG_fail;
5784 }
5785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5786 return resultobj;
5787 fail:
5788 return NULL;
5789 }
5790
5791
5792 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5793 PyObject *resultobj = 0;
5794 wxPoint *arg1 = (wxPoint *) 0 ;
5795 wxPoint *arg2 = 0 ;
5796 wxPoint *result = 0 ;
5797 void *argp1 = 0 ;
5798 int res1 = 0 ;
5799 wxPoint temp2 ;
5800 PyObject * obj0 = 0 ;
5801 PyObject * obj1 = 0 ;
5802 char * kwnames[] = {
5803 (char *) "self",(char *) "pt", NULL
5804 };
5805
5806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5808 if (!SWIG_IsOK(res1)) {
5809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5810 }
5811 arg1 = reinterpret_cast< wxPoint * >(argp1);
5812 {
5813 arg2 = &temp2;
5814 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5815 }
5816 {
5817 PyThreadState* __tstate = wxPyBeginAllowThreads();
5818 {
5819 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5820 result = (wxPoint *) &_result_ref;
5821 }
5822 wxPyEndAllowThreads(__tstate);
5823 if (PyErr_Occurred()) SWIG_fail;
5824 }
5825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5826 return resultobj;
5827 fail:
5828 return NULL;
5829 }
5830
5831
5832 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5833 PyObject *resultobj = 0;
5834 wxPoint *arg1 = (wxPoint *) 0 ;
5835 long arg2 ;
5836 long arg3 ;
5837 void *argp1 = 0 ;
5838 int res1 = 0 ;
5839 long val2 ;
5840 int ecode2 = 0 ;
5841 long val3 ;
5842 int ecode3 = 0 ;
5843 PyObject * obj0 = 0 ;
5844 PyObject * obj1 = 0 ;
5845 PyObject * obj2 = 0 ;
5846 char * kwnames[] = {
5847 (char *) "self",(char *) "x",(char *) "y", NULL
5848 };
5849
5850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5852 if (!SWIG_IsOK(res1)) {
5853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5854 }
5855 arg1 = reinterpret_cast< wxPoint * >(argp1);
5856 ecode2 = SWIG_AsVal_long(obj1, &val2);
5857 if (!SWIG_IsOK(ecode2)) {
5858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5859 }
5860 arg2 = static_cast< long >(val2);
5861 ecode3 = SWIG_AsVal_long(obj2, &val3);
5862 if (!SWIG_IsOK(ecode3)) {
5863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5864 }
5865 arg3 = static_cast< long >(val3);
5866 {
5867 PyThreadState* __tstate = wxPyBeginAllowThreads();
5868 wxPoint_Set(arg1,arg2,arg3);
5869 wxPyEndAllowThreads(__tstate);
5870 if (PyErr_Occurred()) SWIG_fail;
5871 }
5872 resultobj = SWIG_Py_Void();
5873 return resultobj;
5874 fail:
5875 return NULL;
5876 }
5877
5878
5879 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5880 PyObject *resultobj = 0;
5881 wxPoint *arg1 = (wxPoint *) 0 ;
5882 PyObject *result = 0 ;
5883 void *argp1 = 0 ;
5884 int res1 = 0 ;
5885 PyObject *swig_obj[1] ;
5886
5887 if (!args) SWIG_fail;
5888 swig_obj[0] = args;
5889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5890 if (!SWIG_IsOK(res1)) {
5891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5892 }
5893 arg1 = reinterpret_cast< wxPoint * >(argp1);
5894 {
5895 PyThreadState* __tstate = wxPyBeginAllowThreads();
5896 result = (PyObject *)wxPoint_Get(arg1);
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 resultobj = result;
5901 return resultobj;
5902 fail:
5903 return NULL;
5904 }
5905
5906
5907 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5908 PyObject *obj;
5909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5910 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5911 return SWIG_Py_Void();
5912 }
5913
5914 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5915 return SWIG_Python_InitShadowInstance(args);
5916 }
5917
5918 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5919 PyObject *resultobj = 0;
5920 int arg1 = (int) 0 ;
5921 int arg2 = (int) 0 ;
5922 int arg3 = (int) 0 ;
5923 int arg4 = (int) 0 ;
5924 wxRect *result = 0 ;
5925 int val1 ;
5926 int ecode1 = 0 ;
5927 int val2 ;
5928 int ecode2 = 0 ;
5929 int val3 ;
5930 int ecode3 = 0 ;
5931 int val4 ;
5932 int ecode4 = 0 ;
5933 PyObject * obj0 = 0 ;
5934 PyObject * obj1 = 0 ;
5935 PyObject * obj2 = 0 ;
5936 PyObject * obj3 = 0 ;
5937 char * kwnames[] = {
5938 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
5939 };
5940
5941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5942 if (obj0) {
5943 ecode1 = SWIG_AsVal_int(obj0, &val1);
5944 if (!SWIG_IsOK(ecode1)) {
5945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
5946 }
5947 arg1 = static_cast< int >(val1);
5948 }
5949 if (obj1) {
5950 ecode2 = SWIG_AsVal_int(obj1, &val2);
5951 if (!SWIG_IsOK(ecode2)) {
5952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
5953 }
5954 arg2 = static_cast< int >(val2);
5955 }
5956 if (obj2) {
5957 ecode3 = SWIG_AsVal_int(obj2, &val3);
5958 if (!SWIG_IsOK(ecode3)) {
5959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
5960 }
5961 arg3 = static_cast< int >(val3);
5962 }
5963 if (obj3) {
5964 ecode4 = SWIG_AsVal_int(obj3, &val4);
5965 if (!SWIG_IsOK(ecode4)) {
5966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
5967 }
5968 arg4 = static_cast< int >(val4);
5969 }
5970 {
5971 PyThreadState* __tstate = wxPyBeginAllowThreads();
5972 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
5973 wxPyEndAllowThreads(__tstate);
5974 if (PyErr_Occurred()) SWIG_fail;
5975 }
5976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
5977 return resultobj;
5978 fail:
5979 return NULL;
5980 }
5981
5982
5983 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5984 PyObject *resultobj = 0;
5985 wxPoint *arg1 = 0 ;
5986 wxPoint *arg2 = 0 ;
5987 wxRect *result = 0 ;
5988 wxPoint temp1 ;
5989 wxPoint temp2 ;
5990 PyObject * obj0 = 0 ;
5991 PyObject * obj1 = 0 ;
5992 char * kwnames[] = {
5993 (char *) "topLeft",(char *) "bottomRight", NULL
5994 };
5995
5996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
5997 {
5998 arg1 = &temp1;
5999 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6000 }
6001 {
6002 arg2 = &temp2;
6003 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6004 }
6005 {
6006 PyThreadState* __tstate = wxPyBeginAllowThreads();
6007 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6008 wxPyEndAllowThreads(__tstate);
6009 if (PyErr_Occurred()) SWIG_fail;
6010 }
6011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6012 return resultobj;
6013 fail:
6014 return NULL;
6015 }
6016
6017
6018 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6019 PyObject *resultobj = 0;
6020 wxPoint *arg1 = 0 ;
6021 wxSize *arg2 = 0 ;
6022 wxRect *result = 0 ;
6023 wxPoint temp1 ;
6024 wxSize temp2 ;
6025 PyObject * obj0 = 0 ;
6026 PyObject * obj1 = 0 ;
6027 char * kwnames[] = {
6028 (char *) "pos",(char *) "size", NULL
6029 };
6030
6031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6032 {
6033 arg1 = &temp1;
6034 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6035 }
6036 {
6037 arg2 = &temp2;
6038 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6039 }
6040 {
6041 PyThreadState* __tstate = wxPyBeginAllowThreads();
6042 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6043 wxPyEndAllowThreads(__tstate);
6044 if (PyErr_Occurred()) SWIG_fail;
6045 }
6046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6047 return resultobj;
6048 fail:
6049 return NULL;
6050 }
6051
6052
6053 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6054 PyObject *resultobj = 0;
6055 wxSize *arg1 = 0 ;
6056 wxRect *result = 0 ;
6057 wxSize temp1 ;
6058 PyObject * obj0 = 0 ;
6059 char * kwnames[] = {
6060 (char *) "size", NULL
6061 };
6062
6063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6064 {
6065 arg1 = &temp1;
6066 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6067 }
6068 {
6069 PyThreadState* __tstate = wxPyBeginAllowThreads();
6070 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6071 wxPyEndAllowThreads(__tstate);
6072 if (PyErr_Occurred()) SWIG_fail;
6073 }
6074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6075 return resultobj;
6076 fail:
6077 return NULL;
6078 }
6079
6080
6081 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6082 PyObject *resultobj = 0;
6083 wxRect *arg1 = (wxRect *) 0 ;
6084 void *argp1 = 0 ;
6085 int res1 = 0 ;
6086 PyObject *swig_obj[1] ;
6087
6088 if (!args) SWIG_fail;
6089 swig_obj[0] = args;
6090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6091 if (!SWIG_IsOK(res1)) {
6092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6093 }
6094 arg1 = reinterpret_cast< wxRect * >(argp1);
6095 {
6096 PyThreadState* __tstate = wxPyBeginAllowThreads();
6097 delete arg1;
6098
6099 wxPyEndAllowThreads(__tstate);
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 resultobj = SWIG_Py_Void();
6103 return resultobj;
6104 fail:
6105 return NULL;
6106 }
6107
6108
6109 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6110 PyObject *resultobj = 0;
6111 wxRect *arg1 = (wxRect *) 0 ;
6112 int result;
6113 void *argp1 = 0 ;
6114 int res1 = 0 ;
6115 PyObject *swig_obj[1] ;
6116
6117 if (!args) SWIG_fail;
6118 swig_obj[0] = args;
6119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6120 if (!SWIG_IsOK(res1)) {
6121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6122 }
6123 arg1 = reinterpret_cast< wxRect * >(argp1);
6124 {
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 result = (int)((wxRect const *)arg1)->GetX();
6127 wxPyEndAllowThreads(__tstate);
6128 if (PyErr_Occurred()) SWIG_fail;
6129 }
6130 resultobj = SWIG_From_int(static_cast< int >(result));
6131 return resultobj;
6132 fail:
6133 return NULL;
6134 }
6135
6136
6137 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6138 PyObject *resultobj = 0;
6139 wxRect *arg1 = (wxRect *) 0 ;
6140 int arg2 ;
6141 void *argp1 = 0 ;
6142 int res1 = 0 ;
6143 int val2 ;
6144 int ecode2 = 0 ;
6145 PyObject * obj0 = 0 ;
6146 PyObject * obj1 = 0 ;
6147 char * kwnames[] = {
6148 (char *) "self",(char *) "x", NULL
6149 };
6150
6151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6153 if (!SWIG_IsOK(res1)) {
6154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6155 }
6156 arg1 = reinterpret_cast< wxRect * >(argp1);
6157 ecode2 = SWIG_AsVal_int(obj1, &val2);
6158 if (!SWIG_IsOK(ecode2)) {
6159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6160 }
6161 arg2 = static_cast< int >(val2);
6162 {
6163 PyThreadState* __tstate = wxPyBeginAllowThreads();
6164 (arg1)->SetX(arg2);
6165 wxPyEndAllowThreads(__tstate);
6166 if (PyErr_Occurred()) SWIG_fail;
6167 }
6168 resultobj = SWIG_Py_Void();
6169 return resultobj;
6170 fail:
6171 return NULL;
6172 }
6173
6174
6175 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6176 PyObject *resultobj = 0;
6177 wxRect *arg1 = (wxRect *) 0 ;
6178 int result;
6179 void *argp1 = 0 ;
6180 int res1 = 0 ;
6181 PyObject *swig_obj[1] ;
6182
6183 if (!args) SWIG_fail;
6184 swig_obj[0] = args;
6185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6186 if (!SWIG_IsOK(res1)) {
6187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6188 }
6189 arg1 = reinterpret_cast< wxRect * >(argp1);
6190 {
6191 PyThreadState* __tstate = wxPyBeginAllowThreads();
6192 result = (int)(arg1)->GetY();
6193 wxPyEndAllowThreads(__tstate);
6194 if (PyErr_Occurred()) SWIG_fail;
6195 }
6196 resultobj = SWIG_From_int(static_cast< int >(result));
6197 return resultobj;
6198 fail:
6199 return NULL;
6200 }
6201
6202
6203 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6204 PyObject *resultobj = 0;
6205 wxRect *arg1 = (wxRect *) 0 ;
6206 int arg2 ;
6207 void *argp1 = 0 ;
6208 int res1 = 0 ;
6209 int val2 ;
6210 int ecode2 = 0 ;
6211 PyObject * obj0 = 0 ;
6212 PyObject * obj1 = 0 ;
6213 char * kwnames[] = {
6214 (char *) "self",(char *) "y", NULL
6215 };
6216
6217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6219 if (!SWIG_IsOK(res1)) {
6220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6221 }
6222 arg1 = reinterpret_cast< wxRect * >(argp1);
6223 ecode2 = SWIG_AsVal_int(obj1, &val2);
6224 if (!SWIG_IsOK(ecode2)) {
6225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6226 }
6227 arg2 = static_cast< int >(val2);
6228 {
6229 PyThreadState* __tstate = wxPyBeginAllowThreads();
6230 (arg1)->SetY(arg2);
6231 wxPyEndAllowThreads(__tstate);
6232 if (PyErr_Occurred()) SWIG_fail;
6233 }
6234 resultobj = SWIG_Py_Void();
6235 return resultobj;
6236 fail:
6237 return NULL;
6238 }
6239
6240
6241 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6242 PyObject *resultobj = 0;
6243 wxRect *arg1 = (wxRect *) 0 ;
6244 int result;
6245 void *argp1 = 0 ;
6246 int res1 = 0 ;
6247 PyObject *swig_obj[1] ;
6248
6249 if (!args) SWIG_fail;
6250 swig_obj[0] = args;
6251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6252 if (!SWIG_IsOK(res1)) {
6253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6254 }
6255 arg1 = reinterpret_cast< wxRect * >(argp1);
6256 {
6257 PyThreadState* __tstate = wxPyBeginAllowThreads();
6258 result = (int)((wxRect const *)arg1)->GetWidth();
6259 wxPyEndAllowThreads(__tstate);
6260 if (PyErr_Occurred()) SWIG_fail;
6261 }
6262 resultobj = SWIG_From_int(static_cast< int >(result));
6263 return resultobj;
6264 fail:
6265 return NULL;
6266 }
6267
6268
6269 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6270 PyObject *resultobj = 0;
6271 wxRect *arg1 = (wxRect *) 0 ;
6272 int arg2 ;
6273 void *argp1 = 0 ;
6274 int res1 = 0 ;
6275 int val2 ;
6276 int ecode2 = 0 ;
6277 PyObject * obj0 = 0 ;
6278 PyObject * obj1 = 0 ;
6279 char * kwnames[] = {
6280 (char *) "self",(char *) "w", NULL
6281 };
6282
6283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6285 if (!SWIG_IsOK(res1)) {
6286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6287 }
6288 arg1 = reinterpret_cast< wxRect * >(argp1);
6289 ecode2 = SWIG_AsVal_int(obj1, &val2);
6290 if (!SWIG_IsOK(ecode2)) {
6291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6292 }
6293 arg2 = static_cast< int >(val2);
6294 {
6295 PyThreadState* __tstate = wxPyBeginAllowThreads();
6296 (arg1)->SetWidth(arg2);
6297 wxPyEndAllowThreads(__tstate);
6298 if (PyErr_Occurred()) SWIG_fail;
6299 }
6300 resultobj = SWIG_Py_Void();
6301 return resultobj;
6302 fail:
6303 return NULL;
6304 }
6305
6306
6307 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6308 PyObject *resultobj = 0;
6309 wxRect *arg1 = (wxRect *) 0 ;
6310 int result;
6311 void *argp1 = 0 ;
6312 int res1 = 0 ;
6313 PyObject *swig_obj[1] ;
6314
6315 if (!args) SWIG_fail;
6316 swig_obj[0] = args;
6317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6318 if (!SWIG_IsOK(res1)) {
6319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6320 }
6321 arg1 = reinterpret_cast< wxRect * >(argp1);
6322 {
6323 PyThreadState* __tstate = wxPyBeginAllowThreads();
6324 result = (int)((wxRect const *)arg1)->GetHeight();
6325 wxPyEndAllowThreads(__tstate);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 resultobj = SWIG_From_int(static_cast< int >(result));
6329 return resultobj;
6330 fail:
6331 return NULL;
6332 }
6333
6334
6335 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6336 PyObject *resultobj = 0;
6337 wxRect *arg1 = (wxRect *) 0 ;
6338 int arg2 ;
6339 void *argp1 = 0 ;
6340 int res1 = 0 ;
6341 int val2 ;
6342 int ecode2 = 0 ;
6343 PyObject * obj0 = 0 ;
6344 PyObject * obj1 = 0 ;
6345 char * kwnames[] = {
6346 (char *) "self",(char *) "h", NULL
6347 };
6348
6349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6351 if (!SWIG_IsOK(res1)) {
6352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6353 }
6354 arg1 = reinterpret_cast< wxRect * >(argp1);
6355 ecode2 = SWIG_AsVal_int(obj1, &val2);
6356 if (!SWIG_IsOK(ecode2)) {
6357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6358 }
6359 arg2 = static_cast< int >(val2);
6360 {
6361 PyThreadState* __tstate = wxPyBeginAllowThreads();
6362 (arg1)->SetHeight(arg2);
6363 wxPyEndAllowThreads(__tstate);
6364 if (PyErr_Occurred()) SWIG_fail;
6365 }
6366 resultobj = SWIG_Py_Void();
6367 return resultobj;
6368 fail:
6369 return NULL;
6370 }
6371
6372
6373 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6374 PyObject *resultobj = 0;
6375 wxRect *arg1 = (wxRect *) 0 ;
6376 wxPoint result;
6377 void *argp1 = 0 ;
6378 int res1 = 0 ;
6379 PyObject *swig_obj[1] ;
6380
6381 if (!args) SWIG_fail;
6382 swig_obj[0] = args;
6383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6384 if (!SWIG_IsOK(res1)) {
6385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6386 }
6387 arg1 = reinterpret_cast< wxRect * >(argp1);
6388 {
6389 PyThreadState* __tstate = wxPyBeginAllowThreads();
6390 result = ((wxRect const *)arg1)->GetPosition();
6391 wxPyEndAllowThreads(__tstate);
6392 if (PyErr_Occurred()) SWIG_fail;
6393 }
6394 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6395 return resultobj;
6396 fail:
6397 return NULL;
6398 }
6399
6400
6401 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj = 0;
6403 wxRect *arg1 = (wxRect *) 0 ;
6404 wxPoint *arg2 = 0 ;
6405 void *argp1 = 0 ;
6406 int res1 = 0 ;
6407 wxPoint temp2 ;
6408 PyObject * obj0 = 0 ;
6409 PyObject * obj1 = 0 ;
6410 char * kwnames[] = {
6411 (char *) "self",(char *) "p", NULL
6412 };
6413
6414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6416 if (!SWIG_IsOK(res1)) {
6417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6418 }
6419 arg1 = reinterpret_cast< wxRect * >(argp1);
6420 {
6421 arg2 = &temp2;
6422 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6423 }
6424 {
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 (arg1)->SetPosition((wxPoint const &)*arg2);
6427 wxPyEndAllowThreads(__tstate);
6428 if (PyErr_Occurred()) SWIG_fail;
6429 }
6430 resultobj = SWIG_Py_Void();
6431 return resultobj;
6432 fail:
6433 return NULL;
6434 }
6435
6436
6437 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6438 PyObject *resultobj = 0;
6439 wxRect *arg1 = (wxRect *) 0 ;
6440 wxSize result;
6441 void *argp1 = 0 ;
6442 int res1 = 0 ;
6443 PyObject *swig_obj[1] ;
6444
6445 if (!args) SWIG_fail;
6446 swig_obj[0] = args;
6447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6448 if (!SWIG_IsOK(res1)) {
6449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6450 }
6451 arg1 = reinterpret_cast< wxRect * >(argp1);
6452 {
6453 PyThreadState* __tstate = wxPyBeginAllowThreads();
6454 result = ((wxRect const *)arg1)->GetSize();
6455 wxPyEndAllowThreads(__tstate);
6456 if (PyErr_Occurred()) SWIG_fail;
6457 }
6458 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6466 PyObject *resultobj = 0;
6467 wxRect *arg1 = (wxRect *) 0 ;
6468 wxSize *arg2 = 0 ;
6469 void *argp1 = 0 ;
6470 int res1 = 0 ;
6471 wxSize temp2 ;
6472 PyObject * obj0 = 0 ;
6473 PyObject * obj1 = 0 ;
6474 char * kwnames[] = {
6475 (char *) "self",(char *) "s", NULL
6476 };
6477
6478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6480 if (!SWIG_IsOK(res1)) {
6481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6482 }
6483 arg1 = reinterpret_cast< wxRect * >(argp1);
6484 {
6485 arg2 = &temp2;
6486 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6487 }
6488 {
6489 PyThreadState* __tstate = wxPyBeginAllowThreads();
6490 (arg1)->SetSize((wxSize const &)*arg2);
6491 wxPyEndAllowThreads(__tstate);
6492 if (PyErr_Occurred()) SWIG_fail;
6493 }
6494 resultobj = SWIG_Py_Void();
6495 return resultobj;
6496 fail:
6497 return NULL;
6498 }
6499
6500
6501 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6502 PyObject *resultobj = 0;
6503 wxRect *arg1 = (wxRect *) 0 ;
6504 bool result;
6505 void *argp1 = 0 ;
6506 int res1 = 0 ;
6507 PyObject *swig_obj[1] ;
6508
6509 if (!args) SWIG_fail;
6510 swig_obj[0] = args;
6511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6512 if (!SWIG_IsOK(res1)) {
6513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6514 }
6515 arg1 = reinterpret_cast< wxRect * >(argp1);
6516 {
6517 PyThreadState* __tstate = wxPyBeginAllowThreads();
6518 result = (bool)((wxRect const *)arg1)->IsEmpty();
6519 wxPyEndAllowThreads(__tstate);
6520 if (PyErr_Occurred()) SWIG_fail;
6521 }
6522 {
6523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6524 }
6525 return resultobj;
6526 fail:
6527 return NULL;
6528 }
6529
6530
6531 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6532 PyObject *resultobj = 0;
6533 wxRect *arg1 = (wxRect *) 0 ;
6534 wxPoint result;
6535 void *argp1 = 0 ;
6536 int res1 = 0 ;
6537 PyObject *swig_obj[1] ;
6538
6539 if (!args) SWIG_fail;
6540 swig_obj[0] = args;
6541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6542 if (!SWIG_IsOK(res1)) {
6543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6544 }
6545 arg1 = reinterpret_cast< wxRect * >(argp1);
6546 {
6547 PyThreadState* __tstate = wxPyBeginAllowThreads();
6548 result = ((wxRect const *)arg1)->GetTopLeft();
6549 wxPyEndAllowThreads(__tstate);
6550 if (PyErr_Occurred()) SWIG_fail;
6551 }
6552 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6553 return resultobj;
6554 fail:
6555 return NULL;
6556 }
6557
6558
6559 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6560 PyObject *resultobj = 0;
6561 wxRect *arg1 = (wxRect *) 0 ;
6562 wxPoint *arg2 = 0 ;
6563 void *argp1 = 0 ;
6564 int res1 = 0 ;
6565 wxPoint temp2 ;
6566 PyObject * obj0 = 0 ;
6567 PyObject * obj1 = 0 ;
6568 char * kwnames[] = {
6569 (char *) "self",(char *) "p", NULL
6570 };
6571
6572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6574 if (!SWIG_IsOK(res1)) {
6575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6576 }
6577 arg1 = reinterpret_cast< wxRect * >(argp1);
6578 {
6579 arg2 = &temp2;
6580 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6581 }
6582 {
6583 PyThreadState* __tstate = wxPyBeginAllowThreads();
6584 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6585 wxPyEndAllowThreads(__tstate);
6586 if (PyErr_Occurred()) SWIG_fail;
6587 }
6588 resultobj = SWIG_Py_Void();
6589 return resultobj;
6590 fail:
6591 return NULL;
6592 }
6593
6594
6595 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6596 PyObject *resultobj = 0;
6597 wxRect *arg1 = (wxRect *) 0 ;
6598 wxPoint result;
6599 void *argp1 = 0 ;
6600 int res1 = 0 ;
6601 PyObject *swig_obj[1] ;
6602
6603 if (!args) SWIG_fail;
6604 swig_obj[0] = args;
6605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6606 if (!SWIG_IsOK(res1)) {
6607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6608 }
6609 arg1 = reinterpret_cast< wxRect * >(argp1);
6610 {
6611 PyThreadState* __tstate = wxPyBeginAllowThreads();
6612 result = ((wxRect const *)arg1)->GetBottomRight();
6613 wxPyEndAllowThreads(__tstate);
6614 if (PyErr_Occurred()) SWIG_fail;
6615 }
6616 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6617 return resultobj;
6618 fail:
6619 return NULL;
6620 }
6621
6622
6623 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6624 PyObject *resultobj = 0;
6625 wxRect *arg1 = (wxRect *) 0 ;
6626 wxPoint *arg2 = 0 ;
6627 void *argp1 = 0 ;
6628 int res1 = 0 ;
6629 wxPoint temp2 ;
6630 PyObject * obj0 = 0 ;
6631 PyObject * obj1 = 0 ;
6632 char * kwnames[] = {
6633 (char *) "self",(char *) "p", NULL
6634 };
6635
6636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6638 if (!SWIG_IsOK(res1)) {
6639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6640 }
6641 arg1 = reinterpret_cast< wxRect * >(argp1);
6642 {
6643 arg2 = &temp2;
6644 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6645 }
6646 {
6647 PyThreadState* __tstate = wxPyBeginAllowThreads();
6648 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6649 wxPyEndAllowThreads(__tstate);
6650 if (PyErr_Occurred()) SWIG_fail;
6651 }
6652 resultobj = SWIG_Py_Void();
6653 return resultobj;
6654 fail:
6655 return NULL;
6656 }
6657
6658
6659 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6660 PyObject *resultobj = 0;
6661 wxRect *arg1 = (wxRect *) 0 ;
6662 int result;
6663 void *argp1 = 0 ;
6664 int res1 = 0 ;
6665 PyObject *swig_obj[1] ;
6666
6667 if (!args) SWIG_fail;
6668 swig_obj[0] = args;
6669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6670 if (!SWIG_IsOK(res1)) {
6671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6672 }
6673 arg1 = reinterpret_cast< wxRect * >(argp1);
6674 {
6675 PyThreadState* __tstate = wxPyBeginAllowThreads();
6676 result = (int)((wxRect const *)arg1)->GetLeft();
6677 wxPyEndAllowThreads(__tstate);
6678 if (PyErr_Occurred()) SWIG_fail;
6679 }
6680 resultobj = SWIG_From_int(static_cast< int >(result));
6681 return resultobj;
6682 fail:
6683 return NULL;
6684 }
6685
6686
6687 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6688 PyObject *resultobj = 0;
6689 wxRect *arg1 = (wxRect *) 0 ;
6690 int result;
6691 void *argp1 = 0 ;
6692 int res1 = 0 ;
6693 PyObject *swig_obj[1] ;
6694
6695 if (!args) SWIG_fail;
6696 swig_obj[0] = args;
6697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6698 if (!SWIG_IsOK(res1)) {
6699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6700 }
6701 arg1 = reinterpret_cast< wxRect * >(argp1);
6702 {
6703 PyThreadState* __tstate = wxPyBeginAllowThreads();
6704 result = (int)((wxRect const *)arg1)->GetTop();
6705 wxPyEndAllowThreads(__tstate);
6706 if (PyErr_Occurred()) SWIG_fail;
6707 }
6708 resultobj = SWIG_From_int(static_cast< int >(result));
6709 return resultobj;
6710 fail:
6711 return NULL;
6712 }
6713
6714
6715 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6716 PyObject *resultobj = 0;
6717 wxRect *arg1 = (wxRect *) 0 ;
6718 int result;
6719 void *argp1 = 0 ;
6720 int res1 = 0 ;
6721 PyObject *swig_obj[1] ;
6722
6723 if (!args) SWIG_fail;
6724 swig_obj[0] = args;
6725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6726 if (!SWIG_IsOK(res1)) {
6727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6728 }
6729 arg1 = reinterpret_cast< wxRect * >(argp1);
6730 {
6731 PyThreadState* __tstate = wxPyBeginAllowThreads();
6732 result = (int)((wxRect const *)arg1)->GetBottom();
6733 wxPyEndAllowThreads(__tstate);
6734 if (PyErr_Occurred()) SWIG_fail;
6735 }
6736 resultobj = SWIG_From_int(static_cast< int >(result));
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6744 PyObject *resultobj = 0;
6745 wxRect *arg1 = (wxRect *) 0 ;
6746 int result;
6747 void *argp1 = 0 ;
6748 int res1 = 0 ;
6749 PyObject *swig_obj[1] ;
6750
6751 if (!args) SWIG_fail;
6752 swig_obj[0] = args;
6753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6754 if (!SWIG_IsOK(res1)) {
6755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6756 }
6757 arg1 = reinterpret_cast< wxRect * >(argp1);
6758 {
6759 PyThreadState* __tstate = wxPyBeginAllowThreads();
6760 result = (int)((wxRect const *)arg1)->GetRight();
6761 wxPyEndAllowThreads(__tstate);
6762 if (PyErr_Occurred()) SWIG_fail;
6763 }
6764 resultobj = SWIG_From_int(static_cast< int >(result));
6765 return resultobj;
6766 fail:
6767 return NULL;
6768 }
6769
6770
6771 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6772 PyObject *resultobj = 0;
6773 wxRect *arg1 = (wxRect *) 0 ;
6774 int arg2 ;
6775 void *argp1 = 0 ;
6776 int res1 = 0 ;
6777 int val2 ;
6778 int ecode2 = 0 ;
6779 PyObject * obj0 = 0 ;
6780 PyObject * obj1 = 0 ;
6781 char * kwnames[] = {
6782 (char *) "self",(char *) "left", NULL
6783 };
6784
6785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6787 if (!SWIG_IsOK(res1)) {
6788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6789 }
6790 arg1 = reinterpret_cast< wxRect * >(argp1);
6791 ecode2 = SWIG_AsVal_int(obj1, &val2);
6792 if (!SWIG_IsOK(ecode2)) {
6793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6794 }
6795 arg2 = static_cast< int >(val2);
6796 {
6797 PyThreadState* __tstate = wxPyBeginAllowThreads();
6798 (arg1)->SetLeft(arg2);
6799 wxPyEndAllowThreads(__tstate);
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 resultobj = SWIG_Py_Void();
6803 return resultobj;
6804 fail:
6805 return NULL;
6806 }
6807
6808
6809 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6810 PyObject *resultobj = 0;
6811 wxRect *arg1 = (wxRect *) 0 ;
6812 int arg2 ;
6813 void *argp1 = 0 ;
6814 int res1 = 0 ;
6815 int val2 ;
6816 int ecode2 = 0 ;
6817 PyObject * obj0 = 0 ;
6818 PyObject * obj1 = 0 ;
6819 char * kwnames[] = {
6820 (char *) "self",(char *) "right", NULL
6821 };
6822
6823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6825 if (!SWIG_IsOK(res1)) {
6826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6827 }
6828 arg1 = reinterpret_cast< wxRect * >(argp1);
6829 ecode2 = SWIG_AsVal_int(obj1, &val2);
6830 if (!SWIG_IsOK(ecode2)) {
6831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6832 }
6833 arg2 = static_cast< int >(val2);
6834 {
6835 PyThreadState* __tstate = wxPyBeginAllowThreads();
6836 (arg1)->SetRight(arg2);
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 resultobj = SWIG_Py_Void();
6841 return resultobj;
6842 fail:
6843 return NULL;
6844 }
6845
6846
6847 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6848 PyObject *resultobj = 0;
6849 wxRect *arg1 = (wxRect *) 0 ;
6850 int arg2 ;
6851 void *argp1 = 0 ;
6852 int res1 = 0 ;
6853 int val2 ;
6854 int ecode2 = 0 ;
6855 PyObject * obj0 = 0 ;
6856 PyObject * obj1 = 0 ;
6857 char * kwnames[] = {
6858 (char *) "self",(char *) "top", NULL
6859 };
6860
6861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6863 if (!SWIG_IsOK(res1)) {
6864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6865 }
6866 arg1 = reinterpret_cast< wxRect * >(argp1);
6867 ecode2 = SWIG_AsVal_int(obj1, &val2);
6868 if (!SWIG_IsOK(ecode2)) {
6869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6870 }
6871 arg2 = static_cast< int >(val2);
6872 {
6873 PyThreadState* __tstate = wxPyBeginAllowThreads();
6874 (arg1)->SetTop(arg2);
6875 wxPyEndAllowThreads(__tstate);
6876 if (PyErr_Occurred()) SWIG_fail;
6877 }
6878 resultobj = SWIG_Py_Void();
6879 return resultobj;
6880 fail:
6881 return NULL;
6882 }
6883
6884
6885 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6886 PyObject *resultobj = 0;
6887 wxRect *arg1 = (wxRect *) 0 ;
6888 int arg2 ;
6889 void *argp1 = 0 ;
6890 int res1 = 0 ;
6891 int val2 ;
6892 int ecode2 = 0 ;
6893 PyObject * obj0 = 0 ;
6894 PyObject * obj1 = 0 ;
6895 char * kwnames[] = {
6896 (char *) "self",(char *) "bottom", NULL
6897 };
6898
6899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6901 if (!SWIG_IsOK(res1)) {
6902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6903 }
6904 arg1 = reinterpret_cast< wxRect * >(argp1);
6905 ecode2 = SWIG_AsVal_int(obj1, &val2);
6906 if (!SWIG_IsOK(ecode2)) {
6907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6908 }
6909 arg2 = static_cast< int >(val2);
6910 {
6911 PyThreadState* __tstate = wxPyBeginAllowThreads();
6912 (arg1)->SetBottom(arg2);
6913 wxPyEndAllowThreads(__tstate);
6914 if (PyErr_Occurred()) SWIG_fail;
6915 }
6916 resultobj = SWIG_Py_Void();
6917 return resultobj;
6918 fail:
6919 return NULL;
6920 }
6921
6922
6923 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6924 PyObject *resultobj = 0;
6925 wxRect *arg1 = (wxRect *) 0 ;
6926 int arg2 ;
6927 int arg3 ;
6928 wxRect *result = 0 ;
6929 void *argp1 = 0 ;
6930 int res1 = 0 ;
6931 int val2 ;
6932 int ecode2 = 0 ;
6933 int val3 ;
6934 int ecode3 = 0 ;
6935 PyObject * obj0 = 0 ;
6936 PyObject * obj1 = 0 ;
6937 PyObject * obj2 = 0 ;
6938 char * kwnames[] = {
6939 (char *) "self",(char *) "dx",(char *) "dy", NULL
6940 };
6941
6942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6944 if (!SWIG_IsOK(res1)) {
6945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
6946 }
6947 arg1 = reinterpret_cast< wxRect * >(argp1);
6948 ecode2 = SWIG_AsVal_int(obj1, &val2);
6949 if (!SWIG_IsOK(ecode2)) {
6950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
6951 }
6952 arg2 = static_cast< int >(val2);
6953 ecode3 = SWIG_AsVal_int(obj2, &val3);
6954 if (!SWIG_IsOK(ecode3)) {
6955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
6956 }
6957 arg3 = static_cast< int >(val3);
6958 {
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 {
6961 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
6962 result = (wxRect *) &_result_ref;
6963 }
6964 wxPyEndAllowThreads(__tstate);
6965 if (PyErr_Occurred()) SWIG_fail;
6966 }
6967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
6968 return resultobj;
6969 fail:
6970 return NULL;
6971 }
6972
6973
6974 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6975 PyObject *resultobj = 0;
6976 wxRect *arg1 = (wxRect *) 0 ;
6977 int arg2 ;
6978 int arg3 ;
6979 wxRect *result = 0 ;
6980 void *argp1 = 0 ;
6981 int res1 = 0 ;
6982 int val2 ;
6983 int ecode2 = 0 ;
6984 int val3 ;
6985 int ecode3 = 0 ;
6986 PyObject * obj0 = 0 ;
6987 PyObject * obj1 = 0 ;
6988 PyObject * obj2 = 0 ;
6989 char * kwnames[] = {
6990 (char *) "self",(char *) "dx",(char *) "dy", NULL
6991 };
6992
6993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6995 if (!SWIG_IsOK(res1)) {
6996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
6997 }
6998 arg1 = reinterpret_cast< wxRect * >(argp1);
6999 ecode2 = SWIG_AsVal_int(obj1, &val2);
7000 if (!SWIG_IsOK(ecode2)) {
7001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7002 }
7003 arg2 = static_cast< int >(val2);
7004 ecode3 = SWIG_AsVal_int(obj2, &val3);
7005 if (!SWIG_IsOK(ecode3)) {
7006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7007 }
7008 arg3 = static_cast< int >(val3);
7009 {
7010 PyThreadState* __tstate = wxPyBeginAllowThreads();
7011 {
7012 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7013 result = (wxRect *) &_result_ref;
7014 }
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7026 PyObject *resultobj = 0;
7027 wxRect *arg1 = (wxRect *) 0 ;
7028 int arg2 ;
7029 int arg3 ;
7030 void *argp1 = 0 ;
7031 int res1 = 0 ;
7032 int val2 ;
7033 int ecode2 = 0 ;
7034 int val3 ;
7035 int ecode3 = 0 ;
7036 PyObject * obj0 = 0 ;
7037 PyObject * obj1 = 0 ;
7038 PyObject * obj2 = 0 ;
7039 char * kwnames[] = {
7040 (char *) "self",(char *) "dx",(char *) "dy", NULL
7041 };
7042
7043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7045 if (!SWIG_IsOK(res1)) {
7046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7047 }
7048 arg1 = reinterpret_cast< wxRect * >(argp1);
7049 ecode2 = SWIG_AsVal_int(obj1, &val2);
7050 if (!SWIG_IsOK(ecode2)) {
7051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7052 }
7053 arg2 = static_cast< int >(val2);
7054 ecode3 = SWIG_AsVal_int(obj2, &val3);
7055 if (!SWIG_IsOK(ecode3)) {
7056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7057 }
7058 arg3 = static_cast< int >(val3);
7059 {
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 (arg1)->Offset(arg2,arg3);
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 resultobj = SWIG_Py_Void();
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj = 0;
7074 wxRect *arg1 = (wxRect *) 0 ;
7075 wxPoint *arg2 = 0 ;
7076 void *argp1 = 0 ;
7077 int res1 = 0 ;
7078 wxPoint temp2 ;
7079 PyObject * obj0 = 0 ;
7080 PyObject * obj1 = 0 ;
7081 char * kwnames[] = {
7082 (char *) "self",(char *) "pt", NULL
7083 };
7084
7085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7087 if (!SWIG_IsOK(res1)) {
7088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7089 }
7090 arg1 = reinterpret_cast< wxRect * >(argp1);
7091 {
7092 arg2 = &temp2;
7093 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7094 }
7095 {
7096 PyThreadState* __tstate = wxPyBeginAllowThreads();
7097 (arg1)->Offset((wxPoint const &)*arg2);
7098 wxPyEndAllowThreads(__tstate);
7099 if (PyErr_Occurred()) SWIG_fail;
7100 }
7101 resultobj = SWIG_Py_Void();
7102 return resultobj;
7103 fail:
7104 return NULL;
7105 }
7106
7107
7108 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7109 PyObject *resultobj = 0;
7110 wxRect *arg1 = (wxRect *) 0 ;
7111 wxRect *arg2 = 0 ;
7112 wxRect result;
7113 void *argp1 = 0 ;
7114 int res1 = 0 ;
7115 wxRect temp2 ;
7116 PyObject * obj0 = 0 ;
7117 PyObject * obj1 = 0 ;
7118 char * kwnames[] = {
7119 (char *) "self",(char *) "rect", NULL
7120 };
7121
7122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7124 if (!SWIG_IsOK(res1)) {
7125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7126 }
7127 arg1 = reinterpret_cast< wxRect * >(argp1);
7128 {
7129 arg2 = &temp2;
7130 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7131 }
7132 {
7133 PyThreadState* __tstate = wxPyBeginAllowThreads();
7134 result = (arg1)->Intersect((wxRect const &)*arg2);
7135 wxPyEndAllowThreads(__tstate);
7136 if (PyErr_Occurred()) SWIG_fail;
7137 }
7138 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7139 return resultobj;
7140 fail:
7141 return NULL;
7142 }
7143
7144
7145 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7146 PyObject *resultobj = 0;
7147 wxRect *arg1 = (wxRect *) 0 ;
7148 wxRect *arg2 = 0 ;
7149 wxRect result;
7150 void *argp1 = 0 ;
7151 int res1 = 0 ;
7152 wxRect temp2 ;
7153 PyObject * obj0 = 0 ;
7154 PyObject * obj1 = 0 ;
7155 char * kwnames[] = {
7156 (char *) "self",(char *) "rect", NULL
7157 };
7158
7159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7161 if (!SWIG_IsOK(res1)) {
7162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7163 }
7164 arg1 = reinterpret_cast< wxRect * >(argp1);
7165 {
7166 arg2 = &temp2;
7167 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7168 }
7169 {
7170 PyThreadState* __tstate = wxPyBeginAllowThreads();
7171 result = (arg1)->Union((wxRect const &)*arg2);
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7176 return resultobj;
7177 fail:
7178 return NULL;
7179 }
7180
7181
7182 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7183 PyObject *resultobj = 0;
7184 wxRect *arg1 = (wxRect *) 0 ;
7185 wxRect *arg2 = 0 ;
7186 wxRect result;
7187 void *argp1 = 0 ;
7188 int res1 = 0 ;
7189 wxRect temp2 ;
7190 PyObject * obj0 = 0 ;
7191 PyObject * obj1 = 0 ;
7192 char * kwnames[] = {
7193 (char *) "self",(char *) "rect", NULL
7194 };
7195
7196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7198 if (!SWIG_IsOK(res1)) {
7199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7200 }
7201 arg1 = reinterpret_cast< wxRect * >(argp1);
7202 {
7203 arg2 = &temp2;
7204 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7205 }
7206 {
7207 PyThreadState* __tstate = wxPyBeginAllowThreads();
7208 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7209 wxPyEndAllowThreads(__tstate);
7210 if (PyErr_Occurred()) SWIG_fail;
7211 }
7212 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj = 0;
7221 wxRect *arg1 = (wxRect *) 0 ;
7222 wxRect *arg2 = 0 ;
7223 wxRect *result = 0 ;
7224 void *argp1 = 0 ;
7225 int res1 = 0 ;
7226 wxRect temp2 ;
7227 PyObject * obj0 = 0 ;
7228 PyObject * obj1 = 0 ;
7229 char * kwnames[] = {
7230 (char *) "self",(char *) "rect", NULL
7231 };
7232
7233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7235 if (!SWIG_IsOK(res1)) {
7236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7237 }
7238 arg1 = reinterpret_cast< wxRect * >(argp1);
7239 {
7240 arg2 = &temp2;
7241 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7242 }
7243 {
7244 PyThreadState* __tstate = wxPyBeginAllowThreads();
7245 {
7246 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7247 result = (wxRect *) &_result_ref;
7248 }
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7253 return resultobj;
7254 fail:
7255 return NULL;
7256 }
7257
7258
7259 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7260 PyObject *resultobj = 0;
7261 wxRect *arg1 = (wxRect *) 0 ;
7262 wxRect *arg2 = 0 ;
7263 bool result;
7264 void *argp1 = 0 ;
7265 int res1 = 0 ;
7266 wxRect temp2 ;
7267 PyObject * obj0 = 0 ;
7268 PyObject * obj1 = 0 ;
7269 char * kwnames[] = {
7270 (char *) "self",(char *) "rect", NULL
7271 };
7272
7273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7275 if (!SWIG_IsOK(res1)) {
7276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect const *""'");
7277 }
7278 arg1 = reinterpret_cast< wxRect * >(argp1);
7279 {
7280 arg2 = &temp2;
7281 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7282 }
7283 {
7284 PyThreadState* __tstate = wxPyBeginAllowThreads();
7285 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
7286 wxPyEndAllowThreads(__tstate);
7287 if (PyErr_Occurred()) SWIG_fail;
7288 }
7289 {
7290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7291 }
7292 return resultobj;
7293 fail:
7294 return NULL;
7295 }
7296
7297
7298 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7299 PyObject *resultobj = 0;
7300 wxRect *arg1 = (wxRect *) 0 ;
7301 wxRect *arg2 = 0 ;
7302 bool result;
7303 void *argp1 = 0 ;
7304 int res1 = 0 ;
7305 wxRect temp2 ;
7306 PyObject * obj0 = 0 ;
7307 PyObject * obj1 = 0 ;
7308 char * kwnames[] = {
7309 (char *) "self",(char *) "rect", NULL
7310 };
7311
7312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7314 if (!SWIG_IsOK(res1)) {
7315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect const *""'");
7316 }
7317 arg1 = reinterpret_cast< wxRect * >(argp1);
7318 {
7319 arg2 = &temp2;
7320 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7321 }
7322 {
7323 PyThreadState* __tstate = wxPyBeginAllowThreads();
7324 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
7325 wxPyEndAllowThreads(__tstate);
7326 if (PyErr_Occurred()) SWIG_fail;
7327 }
7328 {
7329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7330 }
7331 return resultobj;
7332 fail:
7333 return NULL;
7334 }
7335
7336
7337 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7338 PyObject *resultobj = 0;
7339 wxRect *arg1 = (wxRect *) 0 ;
7340 int arg2 ;
7341 int arg3 ;
7342 bool result;
7343 void *argp1 = 0 ;
7344 int res1 = 0 ;
7345 int val2 ;
7346 int ecode2 = 0 ;
7347 int val3 ;
7348 int ecode3 = 0 ;
7349 PyObject * obj0 = 0 ;
7350 PyObject * obj1 = 0 ;
7351 PyObject * obj2 = 0 ;
7352 char * kwnames[] = {
7353 (char *) "self",(char *) "x",(char *) "y", NULL
7354 };
7355
7356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7358 if (!SWIG_IsOK(res1)) {
7359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7360 }
7361 arg1 = reinterpret_cast< wxRect * >(argp1);
7362 ecode2 = SWIG_AsVal_int(obj1, &val2);
7363 if (!SWIG_IsOK(ecode2)) {
7364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7365 }
7366 arg2 = static_cast< int >(val2);
7367 ecode3 = SWIG_AsVal_int(obj2, &val3);
7368 if (!SWIG_IsOK(ecode3)) {
7369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7370 }
7371 arg3 = static_cast< int >(val3);
7372 {
7373 PyThreadState* __tstate = wxPyBeginAllowThreads();
7374 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7375 wxPyEndAllowThreads(__tstate);
7376 if (PyErr_Occurred()) SWIG_fail;
7377 }
7378 {
7379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7380 }
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj = 0;
7389 wxRect *arg1 = (wxRect *) 0 ;
7390 wxPoint *arg2 = 0 ;
7391 bool result;
7392 void *argp1 = 0 ;
7393 int res1 = 0 ;
7394 wxPoint temp2 ;
7395 PyObject * obj0 = 0 ;
7396 PyObject * obj1 = 0 ;
7397 char * kwnames[] = {
7398 (char *) "self",(char *) "pt", NULL
7399 };
7400
7401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7403 if (!SWIG_IsOK(res1)) {
7404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7405 }
7406 arg1 = reinterpret_cast< wxRect * >(argp1);
7407 {
7408 arg2 = &temp2;
7409 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7410 }
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7414 wxPyEndAllowThreads(__tstate);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 {
7418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7419 }
7420 return resultobj;
7421 fail:
7422 return NULL;
7423 }
7424
7425
7426 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7427 PyObject *resultobj = 0;
7428 wxRect *arg1 = (wxRect *) 0 ;
7429 wxRect *arg2 = 0 ;
7430 bool result;
7431 void *argp1 = 0 ;
7432 int res1 = 0 ;
7433 wxRect temp2 ;
7434 PyObject * obj0 = 0 ;
7435 PyObject * obj1 = 0 ;
7436 char * kwnames[] = {
7437 (char *) "self",(char *) "rect", NULL
7438 };
7439
7440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7442 if (!SWIG_IsOK(res1)) {
7443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7444 }
7445 arg1 = reinterpret_cast< wxRect * >(argp1);
7446 {
7447 arg2 = &temp2;
7448 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7449 }
7450 {
7451 PyThreadState* __tstate = wxPyBeginAllowThreads();
7452 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 {
7457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7458 }
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7466 PyObject *resultobj = 0;
7467 wxRect *arg1 = (wxRect *) 0 ;
7468 wxRect *arg2 = 0 ;
7469 int arg3 = (int) wxBOTH ;
7470 wxRect result;
7471 void *argp1 = 0 ;
7472 int res1 = 0 ;
7473 wxRect temp2 ;
7474 int val3 ;
7475 int ecode3 = 0 ;
7476 PyObject * obj0 = 0 ;
7477 PyObject * obj1 = 0 ;
7478 PyObject * obj2 = 0 ;
7479 char * kwnames[] = {
7480 (char *) "self",(char *) "r",(char *) "dir", NULL
7481 };
7482
7483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7485 if (!SWIG_IsOK(res1)) {
7486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7487 }
7488 arg1 = reinterpret_cast< wxRect * >(argp1);
7489 {
7490 arg2 = &temp2;
7491 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7492 }
7493 if (obj2) {
7494 ecode3 = SWIG_AsVal_int(obj2, &val3);
7495 if (!SWIG_IsOK(ecode3)) {
7496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7497 }
7498 arg3 = static_cast< int >(val3);
7499 }
7500 {
7501 PyThreadState* __tstate = wxPyBeginAllowThreads();
7502 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7503 wxPyEndAllowThreads(__tstate);
7504 if (PyErr_Occurred()) SWIG_fail;
7505 }
7506 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7507 return resultobj;
7508 fail:
7509 return NULL;
7510 }
7511
7512
7513 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7514 PyObject *resultobj = 0;
7515 wxRect *arg1 = (wxRect *) 0 ;
7516 int arg2 ;
7517 void *argp1 = 0 ;
7518 int res1 = 0 ;
7519 int val2 ;
7520 int ecode2 = 0 ;
7521 PyObject *swig_obj[2] ;
7522
7523 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7525 if (!SWIG_IsOK(res1)) {
7526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7527 }
7528 arg1 = reinterpret_cast< wxRect * >(argp1);
7529 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7530 if (!SWIG_IsOK(ecode2)) {
7531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7532 }
7533 arg2 = static_cast< int >(val2);
7534 if (arg1) (arg1)->x = arg2;
7535
7536 resultobj = SWIG_Py_Void();
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7544 PyObject *resultobj = 0;
7545 wxRect *arg1 = (wxRect *) 0 ;
7546 int result;
7547 void *argp1 = 0 ;
7548 int res1 = 0 ;
7549 PyObject *swig_obj[1] ;
7550
7551 if (!args) SWIG_fail;
7552 swig_obj[0] = args;
7553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7554 if (!SWIG_IsOK(res1)) {
7555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7556 }
7557 arg1 = reinterpret_cast< wxRect * >(argp1);
7558 result = (int) ((arg1)->x);
7559 resultobj = SWIG_From_int(static_cast< int >(result));
7560 return resultobj;
7561 fail:
7562 return NULL;
7563 }
7564
7565
7566 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7567 PyObject *resultobj = 0;
7568 wxRect *arg1 = (wxRect *) 0 ;
7569 int arg2 ;
7570 void *argp1 = 0 ;
7571 int res1 = 0 ;
7572 int val2 ;
7573 int ecode2 = 0 ;
7574 PyObject *swig_obj[2] ;
7575
7576 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7578 if (!SWIG_IsOK(res1)) {
7579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7580 }
7581 arg1 = reinterpret_cast< wxRect * >(argp1);
7582 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7583 if (!SWIG_IsOK(ecode2)) {
7584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7585 }
7586 arg2 = static_cast< int >(val2);
7587 if (arg1) (arg1)->y = arg2;
7588
7589 resultobj = SWIG_Py_Void();
7590 return resultobj;
7591 fail:
7592 return NULL;
7593 }
7594
7595
7596 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7597 PyObject *resultobj = 0;
7598 wxRect *arg1 = (wxRect *) 0 ;
7599 int result;
7600 void *argp1 = 0 ;
7601 int res1 = 0 ;
7602 PyObject *swig_obj[1] ;
7603
7604 if (!args) SWIG_fail;
7605 swig_obj[0] = args;
7606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7607 if (!SWIG_IsOK(res1)) {
7608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7609 }
7610 arg1 = reinterpret_cast< wxRect * >(argp1);
7611 result = (int) ((arg1)->y);
7612 resultobj = SWIG_From_int(static_cast< int >(result));
7613 return resultobj;
7614 fail:
7615 return NULL;
7616 }
7617
7618
7619 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7620 PyObject *resultobj = 0;
7621 wxRect *arg1 = (wxRect *) 0 ;
7622 int arg2 ;
7623 void *argp1 = 0 ;
7624 int res1 = 0 ;
7625 int val2 ;
7626 int ecode2 = 0 ;
7627 PyObject *swig_obj[2] ;
7628
7629 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7631 if (!SWIG_IsOK(res1)) {
7632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7633 }
7634 arg1 = reinterpret_cast< wxRect * >(argp1);
7635 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7636 if (!SWIG_IsOK(ecode2)) {
7637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7638 }
7639 arg2 = static_cast< int >(val2);
7640 if (arg1) (arg1)->width = arg2;
7641
7642 resultobj = SWIG_Py_Void();
7643 return resultobj;
7644 fail:
7645 return NULL;
7646 }
7647
7648
7649 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7650 PyObject *resultobj = 0;
7651 wxRect *arg1 = (wxRect *) 0 ;
7652 int result;
7653 void *argp1 = 0 ;
7654 int res1 = 0 ;
7655 PyObject *swig_obj[1] ;
7656
7657 if (!args) SWIG_fail;
7658 swig_obj[0] = args;
7659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7660 if (!SWIG_IsOK(res1)) {
7661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7662 }
7663 arg1 = reinterpret_cast< wxRect * >(argp1);
7664 result = (int) ((arg1)->width);
7665 resultobj = SWIG_From_int(static_cast< int >(result));
7666 return resultobj;
7667 fail:
7668 return NULL;
7669 }
7670
7671
7672 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7673 PyObject *resultobj = 0;
7674 wxRect *arg1 = (wxRect *) 0 ;
7675 int arg2 ;
7676 void *argp1 = 0 ;
7677 int res1 = 0 ;
7678 int val2 ;
7679 int ecode2 = 0 ;
7680 PyObject *swig_obj[2] ;
7681
7682 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7684 if (!SWIG_IsOK(res1)) {
7685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7686 }
7687 arg1 = reinterpret_cast< wxRect * >(argp1);
7688 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7689 if (!SWIG_IsOK(ecode2)) {
7690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7691 }
7692 arg2 = static_cast< int >(val2);
7693 if (arg1) (arg1)->height = arg2;
7694
7695 resultobj = SWIG_Py_Void();
7696 return resultobj;
7697 fail:
7698 return NULL;
7699 }
7700
7701
7702 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7703 PyObject *resultobj = 0;
7704 wxRect *arg1 = (wxRect *) 0 ;
7705 int result;
7706 void *argp1 = 0 ;
7707 int res1 = 0 ;
7708 PyObject *swig_obj[1] ;
7709
7710 if (!args) SWIG_fail;
7711 swig_obj[0] = args;
7712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7713 if (!SWIG_IsOK(res1)) {
7714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7715 }
7716 arg1 = reinterpret_cast< wxRect * >(argp1);
7717 result = (int) ((arg1)->height);
7718 resultobj = SWIG_From_int(static_cast< int >(result));
7719 return resultobj;
7720 fail:
7721 return NULL;
7722 }
7723
7724
7725 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7726 PyObject *resultobj = 0;
7727 wxRect *arg1 = (wxRect *) 0 ;
7728 int arg2 = (int) 0 ;
7729 int arg3 = (int) 0 ;
7730 int arg4 = (int) 0 ;
7731 int arg5 = (int) 0 ;
7732 void *argp1 = 0 ;
7733 int res1 = 0 ;
7734 int val2 ;
7735 int ecode2 = 0 ;
7736 int val3 ;
7737 int ecode3 = 0 ;
7738 int val4 ;
7739 int ecode4 = 0 ;
7740 int val5 ;
7741 int ecode5 = 0 ;
7742 PyObject * obj0 = 0 ;
7743 PyObject * obj1 = 0 ;
7744 PyObject * obj2 = 0 ;
7745 PyObject * obj3 = 0 ;
7746 PyObject * obj4 = 0 ;
7747 char * kwnames[] = {
7748 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7749 };
7750
7751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7753 if (!SWIG_IsOK(res1)) {
7754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7755 }
7756 arg1 = reinterpret_cast< wxRect * >(argp1);
7757 if (obj1) {
7758 ecode2 = SWIG_AsVal_int(obj1, &val2);
7759 if (!SWIG_IsOK(ecode2)) {
7760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7761 }
7762 arg2 = static_cast< int >(val2);
7763 }
7764 if (obj2) {
7765 ecode3 = SWIG_AsVal_int(obj2, &val3);
7766 if (!SWIG_IsOK(ecode3)) {
7767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7768 }
7769 arg3 = static_cast< int >(val3);
7770 }
7771 if (obj3) {
7772 ecode4 = SWIG_AsVal_int(obj3, &val4);
7773 if (!SWIG_IsOK(ecode4)) {
7774 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7775 }
7776 arg4 = static_cast< int >(val4);
7777 }
7778 if (obj4) {
7779 ecode5 = SWIG_AsVal_int(obj4, &val5);
7780 if (!SWIG_IsOK(ecode5)) {
7781 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7782 }
7783 arg5 = static_cast< int >(val5);
7784 }
7785 {
7786 PyThreadState* __tstate = wxPyBeginAllowThreads();
7787 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7788 wxPyEndAllowThreads(__tstate);
7789 if (PyErr_Occurred()) SWIG_fail;
7790 }
7791 resultobj = SWIG_Py_Void();
7792 return resultobj;
7793 fail:
7794 return NULL;
7795 }
7796
7797
7798 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7799 PyObject *resultobj = 0;
7800 wxRect *arg1 = (wxRect *) 0 ;
7801 PyObject *result = 0 ;
7802 void *argp1 = 0 ;
7803 int res1 = 0 ;
7804 PyObject *swig_obj[1] ;
7805
7806 if (!args) SWIG_fail;
7807 swig_obj[0] = args;
7808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7809 if (!SWIG_IsOK(res1)) {
7810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7811 }
7812 arg1 = reinterpret_cast< wxRect * >(argp1);
7813 {
7814 PyThreadState* __tstate = wxPyBeginAllowThreads();
7815 result = (PyObject *)wxRect_Get(arg1);
7816 wxPyEndAllowThreads(__tstate);
7817 if (PyErr_Occurred()) SWIG_fail;
7818 }
7819 resultobj = result;
7820 return resultobj;
7821 fail:
7822 return NULL;
7823 }
7824
7825
7826 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7827 PyObject *obj;
7828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7829 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7830 return SWIG_Py_Void();
7831 }
7832
7833 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7834 return SWIG_Python_InitShadowInstance(args);
7835 }
7836
7837 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7838 PyObject *resultobj = 0;
7839 wxRect *arg1 = (wxRect *) 0 ;
7840 wxRect *arg2 = (wxRect *) 0 ;
7841 PyObject *result = 0 ;
7842 void *argp1 = 0 ;
7843 int res1 = 0 ;
7844 void *argp2 = 0 ;
7845 int res2 = 0 ;
7846 PyObject * obj0 = 0 ;
7847 PyObject * obj1 = 0 ;
7848 char * kwnames[] = {
7849 (char *) "r1",(char *) "r2", NULL
7850 };
7851
7852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7854 if (!SWIG_IsOK(res1)) {
7855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7856 }
7857 arg1 = reinterpret_cast< wxRect * >(argp1);
7858 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7859 if (!SWIG_IsOK(res2)) {
7860 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7861 }
7862 arg2 = reinterpret_cast< wxRect * >(argp2);
7863 {
7864 if (!wxPyCheckForApp()) SWIG_fail;
7865 PyThreadState* __tstate = wxPyBeginAllowThreads();
7866 result = (PyObject *)wxIntersectRect(arg1,arg2);
7867 wxPyEndAllowThreads(__tstate);
7868 if (PyErr_Occurred()) SWIG_fail;
7869 }
7870 resultobj = result;
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7878 PyObject *resultobj = 0;
7879 double arg1 = (double) 0.0 ;
7880 double arg2 = (double) 0.0 ;
7881 wxPoint2D *result = 0 ;
7882 double val1 ;
7883 int ecode1 = 0 ;
7884 double val2 ;
7885 int ecode2 = 0 ;
7886 PyObject * obj0 = 0 ;
7887 PyObject * obj1 = 0 ;
7888 char * kwnames[] = {
7889 (char *) "x",(char *) "y", NULL
7890 };
7891
7892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7893 if (obj0) {
7894 ecode1 = SWIG_AsVal_double(obj0, &val1);
7895 if (!SWIG_IsOK(ecode1)) {
7896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7897 }
7898 arg1 = static_cast< double >(val1);
7899 }
7900 if (obj1) {
7901 ecode2 = SWIG_AsVal_double(obj1, &val2);
7902 if (!SWIG_IsOK(ecode2)) {
7903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7904 }
7905 arg2 = static_cast< double >(val2);
7906 }
7907 {
7908 PyThreadState* __tstate = wxPyBeginAllowThreads();
7909 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7910 wxPyEndAllowThreads(__tstate);
7911 if (PyErr_Occurred()) SWIG_fail;
7912 }
7913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj = 0;
7922 wxPoint2D *arg1 = 0 ;
7923 wxPoint2D *result = 0 ;
7924 wxPoint2D temp1 ;
7925 PyObject * obj0 = 0 ;
7926 char * kwnames[] = {
7927 (char *) "pt", NULL
7928 };
7929
7930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
7931 {
7932 arg1 = &temp1;
7933 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
7934 }
7935 {
7936 PyThreadState* __tstate = wxPyBeginAllowThreads();
7937 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
7948 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7949 PyObject *resultobj = 0;
7950 wxPoint *arg1 = 0 ;
7951 wxPoint2D *result = 0 ;
7952 wxPoint temp1 ;
7953 PyObject * obj0 = 0 ;
7954 char * kwnames[] = {
7955 (char *) "pt", NULL
7956 };
7957
7958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
7959 {
7960 arg1 = &temp1;
7961 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7962 }
7963 {
7964 PyThreadState* __tstate = wxPyBeginAllowThreads();
7965 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
7966 wxPyEndAllowThreads(__tstate);
7967 if (PyErr_Occurred()) SWIG_fail;
7968 }
7969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7970 return resultobj;
7971 fail:
7972 return NULL;
7973 }
7974
7975
7976 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7977 PyObject *resultobj = 0;
7978 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7979 int *arg2 = (int *) 0 ;
7980 int *arg3 = (int *) 0 ;
7981 void *argp1 = 0 ;
7982 int res1 = 0 ;
7983 int temp2 ;
7984 int res2 = SWIG_TMPOBJ ;
7985 int temp3 ;
7986 int res3 = SWIG_TMPOBJ ;
7987 PyObject *swig_obj[1] ;
7988
7989 arg2 = &temp2;
7990 arg3 = &temp3;
7991 if (!args) SWIG_fail;
7992 swig_obj[0] = args;
7993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
7994 if (!SWIG_IsOK(res1)) {
7995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
7996 }
7997 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
7998 {
7999 PyThreadState* __tstate = wxPyBeginAllowThreads();
8000 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8001 wxPyEndAllowThreads(__tstate);
8002 if (PyErr_Occurred()) SWIG_fail;
8003 }
8004 resultobj = SWIG_Py_Void();
8005 if (SWIG_IsTmpObj(res2)) {
8006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8007 } else {
8008 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8009 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8010 }
8011 if (SWIG_IsTmpObj(res3)) {
8012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8013 } else {
8014 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8015 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8016 }
8017 return resultobj;
8018 fail:
8019 return NULL;
8020 }
8021
8022
8023 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 PyObject *resultobj = 0;
8025 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8026 int *arg2 = (int *) 0 ;
8027 int *arg3 = (int *) 0 ;
8028 void *argp1 = 0 ;
8029 int res1 = 0 ;
8030 int temp2 ;
8031 int res2 = SWIG_TMPOBJ ;
8032 int temp3 ;
8033 int res3 = SWIG_TMPOBJ ;
8034 PyObject *swig_obj[1] ;
8035
8036 arg2 = &temp2;
8037 arg3 = &temp3;
8038 if (!args) SWIG_fail;
8039 swig_obj[0] = args;
8040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8041 if (!SWIG_IsOK(res1)) {
8042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8043 }
8044 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8045 {
8046 PyThreadState* __tstate = wxPyBeginAllowThreads();
8047 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8048 wxPyEndAllowThreads(__tstate);
8049 if (PyErr_Occurred()) SWIG_fail;
8050 }
8051 resultobj = SWIG_Py_Void();
8052 if (SWIG_IsTmpObj(res2)) {
8053 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8054 } else {
8055 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8056 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8057 }
8058 if (SWIG_IsTmpObj(res3)) {
8059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8060 } else {
8061 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8063 }
8064 return resultobj;
8065 fail:
8066 return NULL;
8067 }
8068
8069
8070 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8071 PyObject *resultobj = 0;
8072 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8073 double result;
8074 void *argp1 = 0 ;
8075 int res1 = 0 ;
8076 PyObject *swig_obj[1] ;
8077
8078 if (!args) SWIG_fail;
8079 swig_obj[0] = args;
8080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8081 if (!SWIG_IsOK(res1)) {
8082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8083 }
8084 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8085 {
8086 PyThreadState* __tstate = wxPyBeginAllowThreads();
8087 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8088 wxPyEndAllowThreads(__tstate);
8089 if (PyErr_Occurred()) SWIG_fail;
8090 }
8091 resultobj = SWIG_From_double(static_cast< double >(result));
8092 return resultobj;
8093 fail:
8094 return NULL;
8095 }
8096
8097
8098 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8099 PyObject *resultobj = 0;
8100 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8101 double result;
8102 void *argp1 = 0 ;
8103 int res1 = 0 ;
8104 PyObject *swig_obj[1] ;
8105
8106 if (!args) SWIG_fail;
8107 swig_obj[0] = args;
8108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8109 if (!SWIG_IsOK(res1)) {
8110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8111 }
8112 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8113 {
8114 PyThreadState* __tstate = wxPyBeginAllowThreads();
8115 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8116 wxPyEndAllowThreads(__tstate);
8117 if (PyErr_Occurred()) SWIG_fail;
8118 }
8119 resultobj = SWIG_From_double(static_cast< double >(result));
8120 return resultobj;
8121 fail:
8122 return NULL;
8123 }
8124
8125
8126 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8127 PyObject *resultobj = 0;
8128 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8129 double arg2 ;
8130 void *argp1 = 0 ;
8131 int res1 = 0 ;
8132 double val2 ;
8133 int ecode2 = 0 ;
8134 PyObject * obj0 = 0 ;
8135 PyObject * obj1 = 0 ;
8136 char * kwnames[] = {
8137 (char *) "self",(char *) "length", NULL
8138 };
8139
8140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8142 if (!SWIG_IsOK(res1)) {
8143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8144 }
8145 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8146 ecode2 = SWIG_AsVal_double(obj1, &val2);
8147 if (!SWIG_IsOK(ecode2)) {
8148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8149 }
8150 arg2 = static_cast< double >(val2);
8151 {
8152 PyThreadState* __tstate = wxPyBeginAllowThreads();
8153 (arg1)->SetVectorLength(arg2);
8154 wxPyEndAllowThreads(__tstate);
8155 if (PyErr_Occurred()) SWIG_fail;
8156 }
8157 resultobj = SWIG_Py_Void();
8158 return resultobj;
8159 fail:
8160 return NULL;
8161 }
8162
8163
8164 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8165 PyObject *resultobj = 0;
8166 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8167 double arg2 ;
8168 void *argp1 = 0 ;
8169 int res1 = 0 ;
8170 double val2 ;
8171 int ecode2 = 0 ;
8172 PyObject * obj0 = 0 ;
8173 PyObject * obj1 = 0 ;
8174 char * kwnames[] = {
8175 (char *) "self",(char *) "degrees", NULL
8176 };
8177
8178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8180 if (!SWIG_IsOK(res1)) {
8181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8182 }
8183 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8184 ecode2 = SWIG_AsVal_double(obj1, &val2);
8185 if (!SWIG_IsOK(ecode2)) {
8186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8187 }
8188 arg2 = static_cast< double >(val2);
8189 {
8190 PyThreadState* __tstate = wxPyBeginAllowThreads();
8191 (arg1)->SetVectorAngle(arg2);
8192 wxPyEndAllowThreads(__tstate);
8193 if (PyErr_Occurred()) SWIG_fail;
8194 }
8195 resultobj = SWIG_Py_Void();
8196 return resultobj;
8197 fail:
8198 return NULL;
8199 }
8200
8201
8202 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8203 PyObject *resultobj = 0;
8204 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8205 wxPoint2D *arg2 = 0 ;
8206 double result;
8207 void *argp1 = 0 ;
8208 int res1 = 0 ;
8209 wxPoint2D temp2 ;
8210 PyObject * obj0 = 0 ;
8211 PyObject * obj1 = 0 ;
8212 char * kwnames[] = {
8213 (char *) "self",(char *) "pt", NULL
8214 };
8215
8216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8218 if (!SWIG_IsOK(res1)) {
8219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8220 }
8221 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8222 {
8223 arg2 = &temp2;
8224 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8225 }
8226 {
8227 PyThreadState* __tstate = wxPyBeginAllowThreads();
8228 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8229 wxPyEndAllowThreads(__tstate);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 resultobj = SWIG_From_double(static_cast< double >(result));
8233 return resultobj;
8234 fail:
8235 return NULL;
8236 }
8237
8238
8239 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8240 PyObject *resultobj = 0;
8241 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8242 wxPoint2D *arg2 = 0 ;
8243 double result;
8244 void *argp1 = 0 ;
8245 int res1 = 0 ;
8246 wxPoint2D temp2 ;
8247 PyObject * obj0 = 0 ;
8248 PyObject * obj1 = 0 ;
8249 char * kwnames[] = {
8250 (char *) "self",(char *) "pt", NULL
8251 };
8252
8253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8255 if (!SWIG_IsOK(res1)) {
8256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8257 }
8258 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8259 {
8260 arg2 = &temp2;
8261 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8262 }
8263 {
8264 PyThreadState* __tstate = wxPyBeginAllowThreads();
8265 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8266 wxPyEndAllowThreads(__tstate);
8267 if (PyErr_Occurred()) SWIG_fail;
8268 }
8269 resultobj = SWIG_From_double(static_cast< double >(result));
8270 return resultobj;
8271 fail:
8272 return NULL;
8273 }
8274
8275
8276 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8277 PyObject *resultobj = 0;
8278 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8279 wxPoint2D *arg2 = 0 ;
8280 double result;
8281 void *argp1 = 0 ;
8282 int res1 = 0 ;
8283 wxPoint2D temp2 ;
8284 PyObject * obj0 = 0 ;
8285 PyObject * obj1 = 0 ;
8286 char * kwnames[] = {
8287 (char *) "self",(char *) "vec", NULL
8288 };
8289
8290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8292 if (!SWIG_IsOK(res1)) {
8293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8294 }
8295 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8296 {
8297 arg2 = &temp2;
8298 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8299 }
8300 {
8301 PyThreadState* __tstate = wxPyBeginAllowThreads();
8302 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8303 wxPyEndAllowThreads(__tstate);
8304 if (PyErr_Occurred()) SWIG_fail;
8305 }
8306 resultobj = SWIG_From_double(static_cast< double >(result));
8307 return resultobj;
8308 fail:
8309 return NULL;
8310 }
8311
8312
8313 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8314 PyObject *resultobj = 0;
8315 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8316 wxPoint2D *arg2 = 0 ;
8317 double result;
8318 void *argp1 = 0 ;
8319 int res1 = 0 ;
8320 wxPoint2D temp2 ;
8321 PyObject * obj0 = 0 ;
8322 PyObject * obj1 = 0 ;
8323 char * kwnames[] = {
8324 (char *) "self",(char *) "vec", NULL
8325 };
8326
8327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8329 if (!SWIG_IsOK(res1)) {
8330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8331 }
8332 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8333 {
8334 arg2 = &temp2;
8335 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8336 }
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 resultobj = SWIG_From_double(static_cast< double >(result));
8344 return resultobj;
8345 fail:
8346 return NULL;
8347 }
8348
8349
8350 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8351 PyObject *resultobj = 0;
8352 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8353 wxPoint2D result;
8354 void *argp1 = 0 ;
8355 int res1 = 0 ;
8356 PyObject *swig_obj[1] ;
8357
8358 if (!args) SWIG_fail;
8359 swig_obj[0] = args;
8360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8361 if (!SWIG_IsOK(res1)) {
8362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8363 }
8364 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8365 {
8366 PyThreadState* __tstate = wxPyBeginAllowThreads();
8367 result = (arg1)->operator -();
8368 wxPyEndAllowThreads(__tstate);
8369 if (PyErr_Occurred()) SWIG_fail;
8370 }
8371 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8372 return resultobj;
8373 fail:
8374 return NULL;
8375 }
8376
8377
8378 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8379 PyObject *resultobj = 0;
8380 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8381 wxPoint2D *arg2 = 0 ;
8382 wxPoint2D *result = 0 ;
8383 void *argp1 = 0 ;
8384 int res1 = 0 ;
8385 wxPoint2D temp2 ;
8386 PyObject * obj0 = 0 ;
8387 PyObject * obj1 = 0 ;
8388 char * kwnames[] = {
8389 (char *) "self",(char *) "pt", NULL
8390 };
8391
8392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8394 if (!SWIG_IsOK(res1)) {
8395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8396 }
8397 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8398 {
8399 arg2 = &temp2;
8400 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8401 }
8402 {
8403 PyThreadState* __tstate = wxPyBeginAllowThreads();
8404 {
8405 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8406 result = (wxPoint2D *) &_result_ref;
8407 }
8408 wxPyEndAllowThreads(__tstate);
8409 if (PyErr_Occurred()) SWIG_fail;
8410 }
8411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8412 return resultobj;
8413 fail:
8414 return NULL;
8415 }
8416
8417
8418 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8419 PyObject *resultobj = 0;
8420 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8421 wxPoint2D *arg2 = 0 ;
8422 wxPoint2D *result = 0 ;
8423 void *argp1 = 0 ;
8424 int res1 = 0 ;
8425 wxPoint2D temp2 ;
8426 PyObject * obj0 = 0 ;
8427 PyObject * obj1 = 0 ;
8428 char * kwnames[] = {
8429 (char *) "self",(char *) "pt", NULL
8430 };
8431
8432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8434 if (!SWIG_IsOK(res1)) {
8435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8436 }
8437 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8438 {
8439 arg2 = &temp2;
8440 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8441 }
8442 {
8443 PyThreadState* __tstate = wxPyBeginAllowThreads();
8444 {
8445 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8446 result = (wxPoint2D *) &_result_ref;
8447 }
8448 wxPyEndAllowThreads(__tstate);
8449 if (PyErr_Occurred()) SWIG_fail;
8450 }
8451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8459 PyObject *resultobj = 0;
8460 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8461 wxPoint2D *arg2 = 0 ;
8462 wxPoint2D *result = 0 ;
8463 void *argp1 = 0 ;
8464 int res1 = 0 ;
8465 wxPoint2D temp2 ;
8466 PyObject * obj0 = 0 ;
8467 PyObject * obj1 = 0 ;
8468 char * kwnames[] = {
8469 (char *) "self",(char *) "pt", NULL
8470 };
8471
8472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8474 if (!SWIG_IsOK(res1)) {
8475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8476 }
8477 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8478 {
8479 arg2 = &temp2;
8480 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8481 }
8482 {
8483 PyThreadState* __tstate = wxPyBeginAllowThreads();
8484 {
8485 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8486 result = (wxPoint2D *) &_result_ref;
8487 }
8488 wxPyEndAllowThreads(__tstate);
8489 if (PyErr_Occurred()) SWIG_fail;
8490 }
8491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8492 return resultobj;
8493 fail:
8494 return NULL;
8495 }
8496
8497
8498 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8499 PyObject *resultobj = 0;
8500 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8501 wxPoint2D *arg2 = 0 ;
8502 wxPoint2D *result = 0 ;
8503 void *argp1 = 0 ;
8504 int res1 = 0 ;
8505 wxPoint2D temp2 ;
8506 PyObject * obj0 = 0 ;
8507 PyObject * obj1 = 0 ;
8508 char * kwnames[] = {
8509 (char *) "self",(char *) "pt", NULL
8510 };
8511
8512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8514 if (!SWIG_IsOK(res1)) {
8515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8516 }
8517 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8518 {
8519 arg2 = &temp2;
8520 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8521 }
8522 {
8523 PyThreadState* __tstate = wxPyBeginAllowThreads();
8524 {
8525 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8526 result = (wxPoint2D *) &_result_ref;
8527 }
8528 wxPyEndAllowThreads(__tstate);
8529 if (PyErr_Occurred()) SWIG_fail;
8530 }
8531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8532 return resultobj;
8533 fail:
8534 return NULL;
8535 }
8536
8537
8538 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8539 PyObject *resultobj = 0;
8540 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8541 wxPoint2D *arg2 = 0 ;
8542 bool result;
8543 void *argp1 = 0 ;
8544 int res1 = 0 ;
8545 wxPoint2D temp2 ;
8546 PyObject * obj0 = 0 ;
8547 PyObject * obj1 = 0 ;
8548 char * kwnames[] = {
8549 (char *) "self",(char *) "pt", NULL
8550 };
8551
8552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8554 if (!SWIG_IsOK(res1)) {
8555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8556 }
8557 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8558 {
8559 arg2 = &temp2;
8560 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8561 }
8562 {
8563 PyThreadState* __tstate = wxPyBeginAllowThreads();
8564 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
8565 wxPyEndAllowThreads(__tstate);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 {
8569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8570 }
8571 return resultobj;
8572 fail:
8573 return NULL;
8574 }
8575
8576
8577 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8578 PyObject *resultobj = 0;
8579 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8580 wxPoint2D *arg2 = 0 ;
8581 bool result;
8582 void *argp1 = 0 ;
8583 int res1 = 0 ;
8584 wxPoint2D temp2 ;
8585 PyObject * obj0 = 0 ;
8586 PyObject * obj1 = 0 ;
8587 char * kwnames[] = {
8588 (char *) "self",(char *) "pt", NULL
8589 };
8590
8591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8593 if (!SWIG_IsOK(res1)) {
8594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8595 }
8596 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8597 {
8598 arg2 = &temp2;
8599 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8600 }
8601 {
8602 PyThreadState* __tstate = wxPyBeginAllowThreads();
8603 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 {
8608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8609 }
8610 return resultobj;
8611 fail:
8612 return NULL;
8613 }
8614
8615
8616 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8617 PyObject *resultobj = 0;
8618 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8619 double arg2 ;
8620 void *argp1 = 0 ;
8621 int res1 = 0 ;
8622 double val2 ;
8623 int ecode2 = 0 ;
8624 PyObject *swig_obj[2] ;
8625
8626 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8628 if (!SWIG_IsOK(res1)) {
8629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8630 }
8631 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8632 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8633 if (!SWIG_IsOK(ecode2)) {
8634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8635 }
8636 arg2 = static_cast< double >(val2);
8637 if (arg1) (arg1)->m_x = arg2;
8638
8639 resultobj = SWIG_Py_Void();
8640 return resultobj;
8641 fail:
8642 return NULL;
8643 }
8644
8645
8646 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8647 PyObject *resultobj = 0;
8648 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8649 double result;
8650 void *argp1 = 0 ;
8651 int res1 = 0 ;
8652 PyObject *swig_obj[1] ;
8653
8654 if (!args) SWIG_fail;
8655 swig_obj[0] = args;
8656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8657 if (!SWIG_IsOK(res1)) {
8658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8659 }
8660 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8661 result = (double) ((arg1)->m_x);
8662 resultobj = SWIG_From_double(static_cast< double >(result));
8663 return resultobj;
8664 fail:
8665 return NULL;
8666 }
8667
8668
8669 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8670 PyObject *resultobj = 0;
8671 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8672 double arg2 ;
8673 void *argp1 = 0 ;
8674 int res1 = 0 ;
8675 double val2 ;
8676 int ecode2 = 0 ;
8677 PyObject *swig_obj[2] ;
8678
8679 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8681 if (!SWIG_IsOK(res1)) {
8682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8683 }
8684 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8685 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8686 if (!SWIG_IsOK(ecode2)) {
8687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8688 }
8689 arg2 = static_cast< double >(val2);
8690 if (arg1) (arg1)->m_y = arg2;
8691
8692 resultobj = SWIG_Py_Void();
8693 return resultobj;
8694 fail:
8695 return NULL;
8696 }
8697
8698
8699 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8700 PyObject *resultobj = 0;
8701 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8702 double result;
8703 void *argp1 = 0 ;
8704 int res1 = 0 ;
8705 PyObject *swig_obj[1] ;
8706
8707 if (!args) SWIG_fail;
8708 swig_obj[0] = args;
8709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8710 if (!SWIG_IsOK(res1)) {
8711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8712 }
8713 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8714 result = (double) ((arg1)->m_y);
8715 resultobj = SWIG_From_double(static_cast< double >(result));
8716 return resultobj;
8717 fail:
8718 return NULL;
8719 }
8720
8721
8722 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8723 PyObject *resultobj = 0;
8724 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8725 double arg2 = (double) 0 ;
8726 double arg3 = (double) 0 ;
8727 void *argp1 = 0 ;
8728 int res1 = 0 ;
8729 double val2 ;
8730 int ecode2 = 0 ;
8731 double val3 ;
8732 int ecode3 = 0 ;
8733 PyObject * obj0 = 0 ;
8734 PyObject * obj1 = 0 ;
8735 PyObject * obj2 = 0 ;
8736 char * kwnames[] = {
8737 (char *) "self",(char *) "x",(char *) "y", NULL
8738 };
8739
8740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8742 if (!SWIG_IsOK(res1)) {
8743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8744 }
8745 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8746 if (obj1) {
8747 ecode2 = SWIG_AsVal_double(obj1, &val2);
8748 if (!SWIG_IsOK(ecode2)) {
8749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8750 }
8751 arg2 = static_cast< double >(val2);
8752 }
8753 if (obj2) {
8754 ecode3 = SWIG_AsVal_double(obj2, &val3);
8755 if (!SWIG_IsOK(ecode3)) {
8756 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8757 }
8758 arg3 = static_cast< double >(val3);
8759 }
8760 {
8761 PyThreadState* __tstate = wxPyBeginAllowThreads();
8762 wxPoint2D_Set(arg1,arg2,arg3);
8763 wxPyEndAllowThreads(__tstate);
8764 if (PyErr_Occurred()) SWIG_fail;
8765 }
8766 resultobj = SWIG_Py_Void();
8767 return resultobj;
8768 fail:
8769 return NULL;
8770 }
8771
8772
8773 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8774 PyObject *resultobj = 0;
8775 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8776 PyObject *result = 0 ;
8777 void *argp1 = 0 ;
8778 int res1 = 0 ;
8779 PyObject *swig_obj[1] ;
8780
8781 if (!args) SWIG_fail;
8782 swig_obj[0] = args;
8783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8784 if (!SWIG_IsOK(res1)) {
8785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8786 }
8787 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 result = (PyObject *)wxPoint2D_Get(arg1);
8791 wxPyEndAllowThreads(__tstate);
8792 if (PyErr_Occurred()) SWIG_fail;
8793 }
8794 resultobj = result;
8795 return resultobj;
8796 fail:
8797 return NULL;
8798 }
8799
8800
8801 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8802 PyObject *obj;
8803 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8804 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8805 return SWIG_Py_Void();
8806 }
8807
8808 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8809 return SWIG_Python_InitShadowInstance(args);
8810 }
8811
8812 SWIGINTERN int DefaultPosition_set(PyObject *) {
8813 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8814 return 1;
8815 }
8816
8817
8818 SWIGINTERN PyObject *DefaultPosition_get(void) {
8819 PyObject *pyobj = 0;
8820
8821 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8822 return pyobj;
8823 }
8824
8825
8826 SWIGINTERN int DefaultSize_set(PyObject *) {
8827 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8828 return 1;
8829 }
8830
8831
8832 SWIGINTERN PyObject *DefaultSize_get(void) {
8833 PyObject *pyobj = 0;
8834
8835 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8836 return pyobj;
8837 }
8838
8839
8840 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8841 PyObject *resultobj = 0;
8842 PyObject *arg1 = (PyObject *) 0 ;
8843 wxPyInputStream *result = 0 ;
8844 PyObject * obj0 = 0 ;
8845 char * kwnames[] = {
8846 (char *) "p", NULL
8847 };
8848
8849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8850 arg1 = obj0;
8851 {
8852 PyThreadState* __tstate = wxPyBeginAllowThreads();
8853 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8854 wxPyEndAllowThreads(__tstate);
8855 if (PyErr_Occurred()) SWIG_fail;
8856 }
8857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8858 return resultobj;
8859 fail:
8860 return NULL;
8861 }
8862
8863
8864 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8865 PyObject *resultobj = 0;
8866 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8867 void *argp1 = 0 ;
8868 int res1 = 0 ;
8869 PyObject *swig_obj[1] ;
8870
8871 if (!args) SWIG_fail;
8872 swig_obj[0] = args;
8873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8874 if (!SWIG_IsOK(res1)) {
8875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8876 }
8877 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8878 {
8879 PyThreadState* __tstate = wxPyBeginAllowThreads();
8880 delete arg1;
8881
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 resultobj = SWIG_Py_Void();
8886 return resultobj;
8887 fail:
8888 return NULL;
8889 }
8890
8891
8892 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8893 PyObject *resultobj = 0;
8894 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8895 void *argp1 = 0 ;
8896 int res1 = 0 ;
8897 PyObject *swig_obj[1] ;
8898
8899 if (!args) SWIG_fail;
8900 swig_obj[0] = args;
8901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8902 if (!SWIG_IsOK(res1)) {
8903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8904 }
8905 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8906 {
8907 PyThreadState* __tstate = wxPyBeginAllowThreads();
8908 (arg1)->close();
8909 wxPyEndAllowThreads(__tstate);
8910 if (PyErr_Occurred()) SWIG_fail;
8911 }
8912 resultobj = SWIG_Py_Void();
8913 return resultobj;
8914 fail:
8915 return NULL;
8916 }
8917
8918
8919 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8920 PyObject *resultobj = 0;
8921 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8922 void *argp1 = 0 ;
8923 int res1 = 0 ;
8924 PyObject *swig_obj[1] ;
8925
8926 if (!args) SWIG_fail;
8927 swig_obj[0] = args;
8928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8929 if (!SWIG_IsOK(res1)) {
8930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8931 }
8932 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8933 {
8934 PyThreadState* __tstate = wxPyBeginAllowThreads();
8935 (arg1)->flush();
8936 wxPyEndAllowThreads(__tstate);
8937 if (PyErr_Occurred()) SWIG_fail;
8938 }
8939 resultobj = SWIG_Py_Void();
8940 return resultobj;
8941 fail:
8942 return NULL;
8943 }
8944
8945
8946 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8947 PyObject *resultobj = 0;
8948 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8949 bool result;
8950 void *argp1 = 0 ;
8951 int res1 = 0 ;
8952 PyObject *swig_obj[1] ;
8953
8954 if (!args) SWIG_fail;
8955 swig_obj[0] = args;
8956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8957 if (!SWIG_IsOK(res1)) {
8958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8959 }
8960 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8961 {
8962 PyThreadState* __tstate = wxPyBeginAllowThreads();
8963 result = (bool)(arg1)->eof();
8964 wxPyEndAllowThreads(__tstate);
8965 if (PyErr_Occurred()) SWIG_fail;
8966 }
8967 {
8968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8969 }
8970 return resultobj;
8971 fail:
8972 return NULL;
8973 }
8974
8975
8976 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8977 PyObject *resultobj = 0;
8978 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8979 int arg2 = (int) -1 ;
8980 PyObject *result = 0 ;
8981 void *argp1 = 0 ;
8982 int res1 = 0 ;
8983 int val2 ;
8984 int ecode2 = 0 ;
8985 PyObject * obj0 = 0 ;
8986 PyObject * obj1 = 0 ;
8987 char * kwnames[] = {
8988 (char *) "self",(char *) "size", NULL
8989 };
8990
8991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
8992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8993 if (!SWIG_IsOK(res1)) {
8994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8995 }
8996 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8997 if (obj1) {
8998 ecode2 = SWIG_AsVal_int(obj1, &val2);
8999 if (!SWIG_IsOK(ecode2)) {
9000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9001 }
9002 arg2 = static_cast< int >(val2);
9003 }
9004 {
9005 PyThreadState* __tstate = wxPyBeginAllowThreads();
9006 result = (PyObject *)(arg1)->read(arg2);
9007 wxPyEndAllowThreads(__tstate);
9008 if (PyErr_Occurred()) SWIG_fail;
9009 }
9010 resultobj = result;
9011 return resultobj;
9012 fail:
9013 return NULL;
9014 }
9015
9016
9017 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9018 PyObject *resultobj = 0;
9019 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9020 int arg2 = (int) -1 ;
9021 PyObject *result = 0 ;
9022 void *argp1 = 0 ;
9023 int res1 = 0 ;
9024 int val2 ;
9025 int ecode2 = 0 ;
9026 PyObject * obj0 = 0 ;
9027 PyObject * obj1 = 0 ;
9028 char * kwnames[] = {
9029 (char *) "self",(char *) "size", NULL
9030 };
9031
9032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9034 if (!SWIG_IsOK(res1)) {
9035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9036 }
9037 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9038 if (obj1) {
9039 ecode2 = SWIG_AsVal_int(obj1, &val2);
9040 if (!SWIG_IsOK(ecode2)) {
9041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9042 }
9043 arg2 = static_cast< int >(val2);
9044 }
9045 {
9046 PyThreadState* __tstate = wxPyBeginAllowThreads();
9047 result = (PyObject *)(arg1)->readline(arg2);
9048 wxPyEndAllowThreads(__tstate);
9049 if (PyErr_Occurred()) SWIG_fail;
9050 }
9051 resultobj = result;
9052 return resultobj;
9053 fail:
9054 return NULL;
9055 }
9056
9057
9058 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9059 PyObject *resultobj = 0;
9060 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9061 int arg2 = (int) -1 ;
9062 PyObject *result = 0 ;
9063 void *argp1 = 0 ;
9064 int res1 = 0 ;
9065 int val2 ;
9066 int ecode2 = 0 ;
9067 PyObject * obj0 = 0 ;
9068 PyObject * obj1 = 0 ;
9069 char * kwnames[] = {
9070 (char *) "self",(char *) "sizehint", NULL
9071 };
9072
9073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9075 if (!SWIG_IsOK(res1)) {
9076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9077 }
9078 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9079 if (obj1) {
9080 ecode2 = SWIG_AsVal_int(obj1, &val2);
9081 if (!SWIG_IsOK(ecode2)) {
9082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9083 }
9084 arg2 = static_cast< int >(val2);
9085 }
9086 {
9087 PyThreadState* __tstate = wxPyBeginAllowThreads();
9088 result = (PyObject *)(arg1)->readlines(arg2);
9089 wxPyEndAllowThreads(__tstate);
9090 if (PyErr_Occurred()) SWIG_fail;
9091 }
9092 resultobj = result;
9093 return resultobj;
9094 fail:
9095 return NULL;
9096 }
9097
9098
9099 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9100 PyObject *resultobj = 0;
9101 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9102 int arg2 ;
9103 int arg3 = (int) 0 ;
9104 void *argp1 = 0 ;
9105 int res1 = 0 ;
9106 int val2 ;
9107 int ecode2 = 0 ;
9108 int val3 ;
9109 int ecode3 = 0 ;
9110 PyObject * obj0 = 0 ;
9111 PyObject * obj1 = 0 ;
9112 PyObject * obj2 = 0 ;
9113 char * kwnames[] = {
9114 (char *) "self",(char *) "offset",(char *) "whence", NULL
9115 };
9116
9117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9119 if (!SWIG_IsOK(res1)) {
9120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9121 }
9122 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9123 ecode2 = SWIG_AsVal_int(obj1, &val2);
9124 if (!SWIG_IsOK(ecode2)) {
9125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9126 }
9127 arg2 = static_cast< int >(val2);
9128 if (obj2) {
9129 ecode3 = SWIG_AsVal_int(obj2, &val3);
9130 if (!SWIG_IsOK(ecode3)) {
9131 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9132 }
9133 arg3 = static_cast< int >(val3);
9134 }
9135 {
9136 PyThreadState* __tstate = wxPyBeginAllowThreads();
9137 (arg1)->seek(arg2,arg3);
9138 wxPyEndAllowThreads(__tstate);
9139 if (PyErr_Occurred()) SWIG_fail;
9140 }
9141 resultobj = SWIG_Py_Void();
9142 return resultobj;
9143 fail:
9144 return NULL;
9145 }
9146
9147
9148 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9149 PyObject *resultobj = 0;
9150 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9151 int result;
9152 void *argp1 = 0 ;
9153 int res1 = 0 ;
9154 PyObject *swig_obj[1] ;
9155
9156 if (!args) SWIG_fail;
9157 swig_obj[0] = args;
9158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9159 if (!SWIG_IsOK(res1)) {
9160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9161 }
9162 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9163 {
9164 PyThreadState* __tstate = wxPyBeginAllowThreads();
9165 result = (int)(arg1)->tell();
9166 wxPyEndAllowThreads(__tstate);
9167 if (PyErr_Occurred()) SWIG_fail;
9168 }
9169 resultobj = SWIG_From_int(static_cast< int >(result));
9170 return resultobj;
9171 fail:
9172 return NULL;
9173 }
9174
9175
9176 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9177 PyObject *resultobj = 0;
9178 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9179 char result;
9180 void *argp1 = 0 ;
9181 int res1 = 0 ;
9182 PyObject *swig_obj[1] ;
9183
9184 if (!args) SWIG_fail;
9185 swig_obj[0] = args;
9186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9187 if (!SWIG_IsOK(res1)) {
9188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9189 }
9190 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9191 {
9192 PyThreadState* __tstate = wxPyBeginAllowThreads();
9193 result = (char)(arg1)->Peek();
9194 wxPyEndAllowThreads(__tstate);
9195 if (PyErr_Occurred()) SWIG_fail;
9196 }
9197 resultobj = SWIG_From_char(static_cast< char >(result));
9198 return resultobj;
9199 fail:
9200 return NULL;
9201 }
9202
9203
9204 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9205 PyObject *resultobj = 0;
9206 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9207 char result;
9208 void *argp1 = 0 ;
9209 int res1 = 0 ;
9210 PyObject *swig_obj[1] ;
9211
9212 if (!args) SWIG_fail;
9213 swig_obj[0] = args;
9214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9215 if (!SWIG_IsOK(res1)) {
9216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9217 }
9218 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9219 {
9220 PyThreadState* __tstate = wxPyBeginAllowThreads();
9221 result = (char)(arg1)->GetC();
9222 wxPyEndAllowThreads(__tstate);
9223 if (PyErr_Occurred()) SWIG_fail;
9224 }
9225 resultobj = SWIG_From_char(static_cast< char >(result));
9226 return resultobj;
9227 fail:
9228 return NULL;
9229 }
9230
9231
9232 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9233 PyObject *resultobj = 0;
9234 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9235 size_t result;
9236 void *argp1 = 0 ;
9237 int res1 = 0 ;
9238 PyObject *swig_obj[1] ;
9239
9240 if (!args) SWIG_fail;
9241 swig_obj[0] = args;
9242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9243 if (!SWIG_IsOK(res1)) {
9244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9245 }
9246 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9247 {
9248 PyThreadState* __tstate = wxPyBeginAllowThreads();
9249 result = (size_t)(arg1)->LastRead();
9250 wxPyEndAllowThreads(__tstate);
9251 if (PyErr_Occurred()) SWIG_fail;
9252 }
9253 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9254 return resultobj;
9255 fail:
9256 return NULL;
9257 }
9258
9259
9260 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9261 PyObject *resultobj = 0;
9262 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9263 bool result;
9264 void *argp1 = 0 ;
9265 int res1 = 0 ;
9266 PyObject *swig_obj[1] ;
9267
9268 if (!args) SWIG_fail;
9269 swig_obj[0] = args;
9270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9271 if (!SWIG_IsOK(res1)) {
9272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9273 }
9274 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9275 {
9276 PyThreadState* __tstate = wxPyBeginAllowThreads();
9277 result = (bool)(arg1)->CanRead();
9278 wxPyEndAllowThreads(__tstate);
9279 if (PyErr_Occurred()) SWIG_fail;
9280 }
9281 {
9282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9283 }
9284 return resultobj;
9285 fail:
9286 return NULL;
9287 }
9288
9289
9290 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9291 PyObject *resultobj = 0;
9292 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9293 bool result;
9294 void *argp1 = 0 ;
9295 int res1 = 0 ;
9296 PyObject *swig_obj[1] ;
9297
9298 if (!args) SWIG_fail;
9299 swig_obj[0] = args;
9300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9301 if (!SWIG_IsOK(res1)) {
9302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9303 }
9304 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9305 {
9306 PyThreadState* __tstate = wxPyBeginAllowThreads();
9307 result = (bool)(arg1)->Eof();
9308 wxPyEndAllowThreads(__tstate);
9309 if (PyErr_Occurred()) SWIG_fail;
9310 }
9311 {
9312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9313 }
9314 return resultobj;
9315 fail:
9316 return NULL;
9317 }
9318
9319
9320 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9321 PyObject *resultobj = 0;
9322 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9323 char arg2 ;
9324 bool result;
9325 void *argp1 = 0 ;
9326 int res1 = 0 ;
9327 char val2 ;
9328 int ecode2 = 0 ;
9329 PyObject * obj0 = 0 ;
9330 PyObject * obj1 = 0 ;
9331 char * kwnames[] = {
9332 (char *) "self",(char *) "c", NULL
9333 };
9334
9335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9337 if (!SWIG_IsOK(res1)) {
9338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9339 }
9340 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9341 ecode2 = SWIG_AsVal_char(obj1, &val2);
9342 if (!SWIG_IsOK(ecode2)) {
9343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9344 }
9345 arg2 = static_cast< char >(val2);
9346 {
9347 PyThreadState* __tstate = wxPyBeginAllowThreads();
9348 result = (bool)(arg1)->Ungetch(arg2);
9349 wxPyEndAllowThreads(__tstate);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 {
9353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9354 }
9355 return resultobj;
9356 fail:
9357 return NULL;
9358 }
9359
9360
9361 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9362 PyObject *resultobj = 0;
9363 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9364 long arg2 ;
9365 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9366 long result;
9367 void *argp1 = 0 ;
9368 int res1 = 0 ;
9369 long val2 ;
9370 int ecode2 = 0 ;
9371 int val3 ;
9372 int ecode3 = 0 ;
9373 PyObject * obj0 = 0 ;
9374 PyObject * obj1 = 0 ;
9375 PyObject * obj2 = 0 ;
9376 char * kwnames[] = {
9377 (char *) "self",(char *) "pos",(char *) "mode", NULL
9378 };
9379
9380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9382 if (!SWIG_IsOK(res1)) {
9383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9384 }
9385 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9386 ecode2 = SWIG_AsVal_long(obj1, &val2);
9387 if (!SWIG_IsOK(ecode2)) {
9388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9389 }
9390 arg2 = static_cast< long >(val2);
9391 if (obj2) {
9392 ecode3 = SWIG_AsVal_int(obj2, &val3);
9393 if (!SWIG_IsOK(ecode3)) {
9394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9395 }
9396 arg3 = static_cast< wxSeekMode >(val3);
9397 }
9398 {
9399 PyThreadState* __tstate = wxPyBeginAllowThreads();
9400 result = (long)(arg1)->SeekI(arg2,arg3);
9401 wxPyEndAllowThreads(__tstate);
9402 if (PyErr_Occurred()) SWIG_fail;
9403 }
9404 resultobj = SWIG_From_long(static_cast< long >(result));
9405 return resultobj;
9406 fail:
9407 return NULL;
9408 }
9409
9410
9411 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9412 PyObject *resultobj = 0;
9413 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9414 long result;
9415 void *argp1 = 0 ;
9416 int res1 = 0 ;
9417 PyObject *swig_obj[1] ;
9418
9419 if (!args) SWIG_fail;
9420 swig_obj[0] = args;
9421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9422 if (!SWIG_IsOK(res1)) {
9423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9424 }
9425 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9426 {
9427 PyThreadState* __tstate = wxPyBeginAllowThreads();
9428 result = (long)(arg1)->TellI();
9429 wxPyEndAllowThreads(__tstate);
9430 if (PyErr_Occurred()) SWIG_fail;
9431 }
9432 resultobj = SWIG_From_long(static_cast< long >(result));
9433 return resultobj;
9434 fail:
9435 return NULL;
9436 }
9437
9438
9439 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9440 PyObject *obj;
9441 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9442 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9443 return SWIG_Py_Void();
9444 }
9445
9446 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9447 return SWIG_Python_InitShadowInstance(args);
9448 }
9449
9450 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9451 PyObject *resultobj = 0;
9452 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9453 PyObject *arg2 = (PyObject *) 0 ;
9454 void *argp1 = 0 ;
9455 int res1 = 0 ;
9456 PyObject * obj0 = 0 ;
9457 PyObject * obj1 = 0 ;
9458 char * kwnames[] = {
9459 (char *) "self",(char *) "obj", NULL
9460 };
9461
9462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9464 if (!SWIG_IsOK(res1)) {
9465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9466 }
9467 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9468 arg2 = obj1;
9469 {
9470 PyThreadState* __tstate = wxPyBeginAllowThreads();
9471 wxOutputStream_write(arg1,arg2);
9472 wxPyEndAllowThreads(__tstate);
9473 if (PyErr_Occurred()) SWIG_fail;
9474 }
9475 resultobj = SWIG_Py_Void();
9476 return resultobj;
9477 fail:
9478 return NULL;
9479 }
9480
9481
9482 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9483 PyObject *resultobj = 0;
9484 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9485 size_t result;
9486 void *argp1 = 0 ;
9487 int res1 = 0 ;
9488 PyObject *swig_obj[1] ;
9489
9490 if (!args) SWIG_fail;
9491 swig_obj[0] = args;
9492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9493 if (!SWIG_IsOK(res1)) {
9494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9495 }
9496 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9497 {
9498 PyThreadState* __tstate = wxPyBeginAllowThreads();
9499 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9500 wxPyEndAllowThreads(__tstate);
9501 if (PyErr_Occurred()) SWIG_fail;
9502 }
9503 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9504 return resultobj;
9505 fail:
9506 return NULL;
9507 }
9508
9509
9510 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9511 PyObject *obj;
9512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9513 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9514 return SWIG_Py_Void();
9515 }
9516
9517 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9518 PyObject *resultobj = 0;
9519 wxInputStream *arg1 = (wxInputStream *) 0 ;
9520 wxString *arg2 = 0 ;
9521 wxString *arg3 = 0 ;
9522 wxString *arg4 = 0 ;
9523 wxDateTime arg5 ;
9524 wxFSFile *result = 0 ;
9525 wxPyInputStream *temp1 ;
9526 bool temp2 = false ;
9527 bool temp3 = false ;
9528 bool temp4 = false ;
9529 void *argp5 ;
9530 int res5 = 0 ;
9531 PyObject * obj0 = 0 ;
9532 PyObject * obj1 = 0 ;
9533 PyObject * obj2 = 0 ;
9534 PyObject * obj3 = 0 ;
9535 PyObject * obj4 = 0 ;
9536 char * kwnames[] = {
9537 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9538 };
9539
9540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9541 {
9542 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9543 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9544 } else {
9545 PyErr_Clear(); // clear the failure of the wxPyConvert above
9546 arg1 = wxPyCBInputStream_create(obj0, true);
9547 if (arg1 == NULL) {
9548 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9549 SWIG_fail;
9550 }
9551 }
9552 }
9553 {
9554 arg2 = wxString_in_helper(obj1);
9555 if (arg2 == NULL) SWIG_fail;
9556 temp2 = true;
9557 }
9558 {
9559 arg3 = wxString_in_helper(obj2);
9560 if (arg3 == NULL) SWIG_fail;
9561 temp3 = true;
9562 }
9563 {
9564 arg4 = wxString_in_helper(obj3);
9565 if (arg4 == NULL) SWIG_fail;
9566 temp4 = true;
9567 }
9568 {
9569 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9570 if (!SWIG_IsOK(res5)) {
9571 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9572 }
9573 if (!argp5) {
9574 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9575 } else {
9576 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9577 arg5 = *temp;
9578 if (SWIG_IsNewObj(res5)) delete temp;
9579 }
9580 }
9581 {
9582 PyThreadState* __tstate = wxPyBeginAllowThreads();
9583 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9584 wxPyEndAllowThreads(__tstate);
9585 if (PyErr_Occurred()) SWIG_fail;
9586 }
9587 {
9588 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9589 }
9590 {
9591 if (temp2)
9592 delete arg2;
9593 }
9594 {
9595 if (temp3)
9596 delete arg3;
9597 }
9598 {
9599 if (temp4)
9600 delete arg4;
9601 }
9602 return resultobj;
9603 fail:
9604 {
9605 if (temp2)
9606 delete arg2;
9607 }
9608 {
9609 if (temp3)
9610 delete arg3;
9611 }
9612 {
9613 if (temp4)
9614 delete arg4;
9615 }
9616 return NULL;
9617 }
9618
9619
9620 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9621 PyObject *resultobj = 0;
9622 wxFSFile *arg1 = (wxFSFile *) 0 ;
9623 void *argp1 = 0 ;
9624 int res1 = 0 ;
9625 PyObject *swig_obj[1] ;
9626
9627 if (!args) SWIG_fail;
9628 swig_obj[0] = args;
9629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9630 if (!SWIG_IsOK(res1)) {
9631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9632 }
9633 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9634 {
9635 PyThreadState* __tstate = wxPyBeginAllowThreads();
9636 delete arg1;
9637
9638 wxPyEndAllowThreads(__tstate);
9639 if (PyErr_Occurred()) SWIG_fail;
9640 }
9641 resultobj = SWIG_Py_Void();
9642 return resultobj;
9643 fail:
9644 return NULL;
9645 }
9646
9647
9648 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9649 PyObject *resultobj = 0;
9650 wxFSFile *arg1 = (wxFSFile *) 0 ;
9651 wxInputStream *result = 0 ;
9652 void *argp1 = 0 ;
9653 int res1 = 0 ;
9654 PyObject *swig_obj[1] ;
9655
9656 if (!args) SWIG_fail;
9657 swig_obj[0] = args;
9658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9659 if (!SWIG_IsOK(res1)) {
9660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9661 }
9662 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9663 {
9664 PyThreadState* __tstate = wxPyBeginAllowThreads();
9665 result = (wxInputStream *)(arg1)->GetStream();
9666 wxPyEndAllowThreads(__tstate);
9667 if (PyErr_Occurred()) SWIG_fail;
9668 }
9669 {
9670 wxPyInputStream * _ptr = NULL;
9671
9672 if (result) {
9673 _ptr = new wxPyInputStream(result);
9674 }
9675 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9676 }
9677 return resultobj;
9678 fail:
9679 return NULL;
9680 }
9681
9682
9683 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9684 PyObject *resultobj = 0;
9685 wxFSFile *arg1 = (wxFSFile *) 0 ;
9686 wxString *result = 0 ;
9687 void *argp1 = 0 ;
9688 int res1 = 0 ;
9689 PyObject *swig_obj[1] ;
9690
9691 if (!args) SWIG_fail;
9692 swig_obj[0] = args;
9693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9694 if (!SWIG_IsOK(res1)) {
9695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9696 }
9697 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9698 {
9699 PyThreadState* __tstate = wxPyBeginAllowThreads();
9700 {
9701 wxString const &_result_ref = (arg1)->GetMimeType();
9702 result = (wxString *) &_result_ref;
9703 }
9704 wxPyEndAllowThreads(__tstate);
9705 if (PyErr_Occurred()) SWIG_fail;
9706 }
9707 {
9708 #if wxUSE_UNICODE
9709 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9710 #else
9711 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9712 #endif
9713 }
9714 return resultobj;
9715 fail:
9716 return NULL;
9717 }
9718
9719
9720 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9721 PyObject *resultobj = 0;
9722 wxFSFile *arg1 = (wxFSFile *) 0 ;
9723 wxString *result = 0 ;
9724 void *argp1 = 0 ;
9725 int res1 = 0 ;
9726 PyObject *swig_obj[1] ;
9727
9728 if (!args) SWIG_fail;
9729 swig_obj[0] = args;
9730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9731 if (!SWIG_IsOK(res1)) {
9732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9733 }
9734 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9735 {
9736 PyThreadState* __tstate = wxPyBeginAllowThreads();
9737 {
9738 wxString const &_result_ref = (arg1)->GetLocation();
9739 result = (wxString *) &_result_ref;
9740 }
9741 wxPyEndAllowThreads(__tstate);
9742 if (PyErr_Occurred()) SWIG_fail;
9743 }
9744 {
9745 #if wxUSE_UNICODE
9746 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9747 #else
9748 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9749 #endif
9750 }
9751 return resultobj;
9752 fail:
9753 return NULL;
9754 }
9755
9756
9757 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9758 PyObject *resultobj = 0;
9759 wxFSFile *arg1 = (wxFSFile *) 0 ;
9760 wxString *result = 0 ;
9761 void *argp1 = 0 ;
9762 int res1 = 0 ;
9763 PyObject *swig_obj[1] ;
9764
9765 if (!args) SWIG_fail;
9766 swig_obj[0] = args;
9767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9768 if (!SWIG_IsOK(res1)) {
9769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9770 }
9771 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9772 {
9773 PyThreadState* __tstate = wxPyBeginAllowThreads();
9774 {
9775 wxString const &_result_ref = (arg1)->GetAnchor();
9776 result = (wxString *) &_result_ref;
9777 }
9778 wxPyEndAllowThreads(__tstate);
9779 if (PyErr_Occurred()) SWIG_fail;
9780 }
9781 {
9782 #if wxUSE_UNICODE
9783 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9784 #else
9785 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9786 #endif
9787 }
9788 return resultobj;
9789 fail:
9790 return NULL;
9791 }
9792
9793
9794 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9795 PyObject *resultobj = 0;
9796 wxFSFile *arg1 = (wxFSFile *) 0 ;
9797 wxDateTime result;
9798 void *argp1 = 0 ;
9799 int res1 = 0 ;
9800 PyObject *swig_obj[1] ;
9801
9802 if (!args) SWIG_fail;
9803 swig_obj[0] = args;
9804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9805 if (!SWIG_IsOK(res1)) {
9806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9807 }
9808 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9809 {
9810 PyThreadState* __tstate = wxPyBeginAllowThreads();
9811 result = (arg1)->GetModificationTime();
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9816 return resultobj;
9817 fail:
9818 return NULL;
9819 }
9820
9821
9822 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9823 PyObject *obj;
9824 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9825 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9826 return SWIG_Py_Void();
9827 }
9828
9829 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9830 return SWIG_Python_InitShadowInstance(args);
9831 }
9832
9833 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9834 PyObject *obj;
9835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9836 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9837 return SWIG_Py_Void();
9838 }
9839
9840 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9841 PyObject *resultobj = 0;
9842 wxPyFileSystemHandler *result = 0 ;
9843
9844 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9845 {
9846 PyThreadState* __tstate = wxPyBeginAllowThreads();
9847 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9852 return resultobj;
9853 fail:
9854 return NULL;
9855 }
9856
9857
9858 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9859 PyObject *resultobj = 0;
9860 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9861 PyObject *arg2 = (PyObject *) 0 ;
9862 PyObject *arg3 = (PyObject *) 0 ;
9863 void *argp1 = 0 ;
9864 int res1 = 0 ;
9865 PyObject * obj0 = 0 ;
9866 PyObject * obj1 = 0 ;
9867 PyObject * obj2 = 0 ;
9868 char * kwnames[] = {
9869 (char *) "self",(char *) "self",(char *) "_class", NULL
9870 };
9871
9872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9874 if (!SWIG_IsOK(res1)) {
9875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9876 }
9877 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9878 arg2 = obj1;
9879 arg3 = obj2;
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 (arg1)->_setCallbackInfo(arg2,arg3);
9883 wxPyEndAllowThreads(__tstate);
9884 if (PyErr_Occurred()) SWIG_fail;
9885 }
9886 resultobj = SWIG_Py_Void();
9887 return resultobj;
9888 fail:
9889 return NULL;
9890 }
9891
9892
9893 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9894 PyObject *resultobj = 0;
9895 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9896 wxString *arg2 = 0 ;
9897 bool result;
9898 void *argp1 = 0 ;
9899 int res1 = 0 ;
9900 bool temp2 = false ;
9901 PyObject * obj0 = 0 ;
9902 PyObject * obj1 = 0 ;
9903 char * kwnames[] = {
9904 (char *) "self",(char *) "location", NULL
9905 };
9906
9907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9909 if (!SWIG_IsOK(res1)) {
9910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9911 }
9912 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9913 {
9914 arg2 = wxString_in_helper(obj1);
9915 if (arg2 == NULL) SWIG_fail;
9916 temp2 = true;
9917 }
9918 {
9919 PyThreadState* __tstate = wxPyBeginAllowThreads();
9920 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9921 wxPyEndAllowThreads(__tstate);
9922 if (PyErr_Occurred()) SWIG_fail;
9923 }
9924 {
9925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9926 }
9927 {
9928 if (temp2)
9929 delete arg2;
9930 }
9931 return resultobj;
9932 fail:
9933 {
9934 if (temp2)
9935 delete arg2;
9936 }
9937 return NULL;
9938 }
9939
9940
9941 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9942 PyObject *resultobj = 0;
9943 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9944 wxFileSystem *arg2 = 0 ;
9945 wxString *arg3 = 0 ;
9946 wxFSFile *result = 0 ;
9947 void *argp1 = 0 ;
9948 int res1 = 0 ;
9949 void *argp2 = 0 ;
9950 int res2 = 0 ;
9951 bool temp3 = false ;
9952 PyObject * obj0 = 0 ;
9953 PyObject * obj1 = 0 ;
9954 PyObject * obj2 = 0 ;
9955 char * kwnames[] = {
9956 (char *) "self",(char *) "fs",(char *) "location", NULL
9957 };
9958
9959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9961 if (!SWIG_IsOK(res1)) {
9962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9963 }
9964 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9965 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
9966 if (!SWIG_IsOK(res2)) {
9967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9968 }
9969 if (!argp2) {
9970 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9971 }
9972 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
9973 {
9974 arg3 = wxString_in_helper(obj2);
9975 if (arg3 == NULL) SWIG_fail;
9976 temp3 = true;
9977 }
9978 {
9979 PyThreadState* __tstate = wxPyBeginAllowThreads();
9980 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9981 wxPyEndAllowThreads(__tstate);
9982 if (PyErr_Occurred()) SWIG_fail;
9983 }
9984 {
9985 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
9986 }
9987 {
9988 if (temp3)
9989 delete arg3;
9990 }
9991 return resultobj;
9992 fail:
9993 {
9994 if (temp3)
9995 delete arg3;
9996 }
9997 return NULL;
9998 }
9999
10000
10001 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10002 PyObject *resultobj = 0;
10003 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10004 wxString *arg2 = 0 ;
10005 int arg3 = (int) 0 ;
10006 wxString result;
10007 void *argp1 = 0 ;
10008 int res1 = 0 ;
10009 bool temp2 = false ;
10010 int val3 ;
10011 int ecode3 = 0 ;
10012 PyObject * obj0 = 0 ;
10013 PyObject * obj1 = 0 ;
10014 PyObject * obj2 = 0 ;
10015 char * kwnames[] = {
10016 (char *) "self",(char *) "spec",(char *) "flags", NULL
10017 };
10018
10019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10021 if (!SWIG_IsOK(res1)) {
10022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10023 }
10024 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10025 {
10026 arg2 = wxString_in_helper(obj1);
10027 if (arg2 == NULL) SWIG_fail;
10028 temp2 = true;
10029 }
10030 if (obj2) {
10031 ecode3 = SWIG_AsVal_int(obj2, &val3);
10032 if (!SWIG_IsOK(ecode3)) {
10033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10034 }
10035 arg3 = static_cast< int >(val3);
10036 }
10037 {
10038 PyThreadState* __tstate = wxPyBeginAllowThreads();
10039 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10040 wxPyEndAllowThreads(__tstate);
10041 if (PyErr_Occurred()) SWIG_fail;
10042 }
10043 {
10044 #if wxUSE_UNICODE
10045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10046 #else
10047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10048 #endif
10049 }
10050 {
10051 if (temp2)
10052 delete arg2;
10053 }
10054 return resultobj;
10055 fail:
10056 {
10057 if (temp2)
10058 delete arg2;
10059 }
10060 return NULL;
10061 }
10062
10063
10064 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10065 PyObject *resultobj = 0;
10066 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10067 wxString result;
10068 void *argp1 = 0 ;
10069 int res1 = 0 ;
10070 PyObject *swig_obj[1] ;
10071
10072 if (!args) SWIG_fail;
10073 swig_obj[0] = args;
10074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10075 if (!SWIG_IsOK(res1)) {
10076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10077 }
10078 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10079 {
10080 PyThreadState* __tstate = wxPyBeginAllowThreads();
10081 result = (arg1)->FindNext();
10082 wxPyEndAllowThreads(__tstate);
10083 if (PyErr_Occurred()) SWIG_fail;
10084 }
10085 {
10086 #if wxUSE_UNICODE
10087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10088 #else
10089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10090 #endif
10091 }
10092 return resultobj;
10093 fail:
10094 return NULL;
10095 }
10096
10097
10098 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10099 PyObject *resultobj = 0;
10100 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10101 wxString *arg2 = 0 ;
10102 wxString result;
10103 void *argp1 = 0 ;
10104 int res1 = 0 ;
10105 bool temp2 = false ;
10106 PyObject * obj0 = 0 ;
10107 PyObject * obj1 = 0 ;
10108 char * kwnames[] = {
10109 (char *) "self",(char *) "location", NULL
10110 };
10111
10112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10114 if (!SWIG_IsOK(res1)) {
10115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10116 }
10117 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10118 {
10119 arg2 = wxString_in_helper(obj1);
10120 if (arg2 == NULL) SWIG_fail;
10121 temp2 = true;
10122 }
10123 {
10124 PyThreadState* __tstate = wxPyBeginAllowThreads();
10125 result = (arg1)->GetProtocol((wxString const &)*arg2);
10126 wxPyEndAllowThreads(__tstate);
10127 if (PyErr_Occurred()) SWIG_fail;
10128 }
10129 {
10130 #if wxUSE_UNICODE
10131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10132 #else
10133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10134 #endif
10135 }
10136 {
10137 if (temp2)
10138 delete arg2;
10139 }
10140 return resultobj;
10141 fail:
10142 {
10143 if (temp2)
10144 delete arg2;
10145 }
10146 return NULL;
10147 }
10148
10149
10150 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10151 PyObject *resultobj = 0;
10152 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10153 wxString *arg2 = 0 ;
10154 wxString result;
10155 void *argp1 = 0 ;
10156 int res1 = 0 ;
10157 bool temp2 = false ;
10158 PyObject * obj0 = 0 ;
10159 PyObject * obj1 = 0 ;
10160 char * kwnames[] = {
10161 (char *) "self",(char *) "location", NULL
10162 };
10163
10164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10166 if (!SWIG_IsOK(res1)) {
10167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10168 }
10169 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10170 {
10171 arg2 = wxString_in_helper(obj1);
10172 if (arg2 == NULL) SWIG_fail;
10173 temp2 = true;
10174 }
10175 {
10176 PyThreadState* __tstate = wxPyBeginAllowThreads();
10177 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10178 wxPyEndAllowThreads(__tstate);
10179 if (PyErr_Occurred()) SWIG_fail;
10180 }
10181 {
10182 #if wxUSE_UNICODE
10183 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10184 #else
10185 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10186 #endif
10187 }
10188 {
10189 if (temp2)
10190 delete arg2;
10191 }
10192 return resultobj;
10193 fail:
10194 {
10195 if (temp2)
10196 delete arg2;
10197 }
10198 return NULL;
10199 }
10200
10201
10202 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(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_GetAnchor",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_GetAnchor" "', 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)->GetAnchor((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_GetRightLocation(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_GetRightLocation",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_GetRightLocation" "', 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)->GetRightLocation((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_GetMimeTypeFromExt(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_GetMimeTypeFromExt",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_GetMimeTypeFromExt" "', 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)->GetMimeTypeFromExt((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 *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10359 PyObject *obj;
10360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10361 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10362 return SWIG_Py_Void();
10363 }
10364
10365 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10366 return SWIG_Python_InitShadowInstance(args);
10367 }
10368
10369 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10370 PyObject *resultobj = 0;
10371 wxFileSystem *result = 0 ;
10372
10373 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10374 {
10375 PyThreadState* __tstate = wxPyBeginAllowThreads();
10376 result = (wxFileSystem *)new wxFileSystem();
10377 wxPyEndAllowThreads(__tstate);
10378 if (PyErr_Occurred()) SWIG_fail;
10379 }
10380 {
10381 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10382 }
10383 return resultobj;
10384 fail:
10385 return NULL;
10386 }
10387
10388
10389 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10390 PyObject *resultobj = 0;
10391 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10392 void *argp1 = 0 ;
10393 int res1 = 0 ;
10394 PyObject *swig_obj[1] ;
10395
10396 if (!args) SWIG_fail;
10397 swig_obj[0] = args;
10398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10399 if (!SWIG_IsOK(res1)) {
10400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10401 }
10402 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10403 {
10404 PyThreadState* __tstate = wxPyBeginAllowThreads();
10405 delete arg1;
10406
10407 wxPyEndAllowThreads(__tstate);
10408 if (PyErr_Occurred()) SWIG_fail;
10409 }
10410 resultobj = SWIG_Py_Void();
10411 return resultobj;
10412 fail:
10413 return NULL;
10414 }
10415
10416
10417 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10418 PyObject *resultobj = 0;
10419 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10420 wxString *arg2 = 0 ;
10421 bool arg3 = (bool) false ;
10422 void *argp1 = 0 ;
10423 int res1 = 0 ;
10424 bool temp2 = false ;
10425 bool val3 ;
10426 int ecode3 = 0 ;
10427 PyObject * obj0 = 0 ;
10428 PyObject * obj1 = 0 ;
10429 PyObject * obj2 = 0 ;
10430 char * kwnames[] = {
10431 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10432 };
10433
10434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10436 if (!SWIG_IsOK(res1)) {
10437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10438 }
10439 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10440 {
10441 arg2 = wxString_in_helper(obj1);
10442 if (arg2 == NULL) SWIG_fail;
10443 temp2 = true;
10444 }
10445 if (obj2) {
10446 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10447 if (!SWIG_IsOK(ecode3)) {
10448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10449 }
10450 arg3 = static_cast< bool >(val3);
10451 }
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10455 wxPyEndAllowThreads(__tstate);
10456 if (PyErr_Occurred()) SWIG_fail;
10457 }
10458 resultobj = SWIG_Py_Void();
10459 {
10460 if (temp2)
10461 delete arg2;
10462 }
10463 return resultobj;
10464 fail:
10465 {
10466 if (temp2)
10467 delete arg2;
10468 }
10469 return NULL;
10470 }
10471
10472
10473 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10474 PyObject *resultobj = 0;
10475 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10476 wxString result;
10477 void *argp1 = 0 ;
10478 int res1 = 0 ;
10479 PyObject *swig_obj[1] ;
10480
10481 if (!args) SWIG_fail;
10482 swig_obj[0] = args;
10483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10484 if (!SWIG_IsOK(res1)) {
10485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10486 }
10487 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (arg1)->GetPath();
10491 wxPyEndAllowThreads(__tstate);
10492 if (PyErr_Occurred()) SWIG_fail;
10493 }
10494 {
10495 #if wxUSE_UNICODE
10496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10497 #else
10498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10499 #endif
10500 }
10501 return resultobj;
10502 fail:
10503 return NULL;
10504 }
10505
10506
10507 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10508 PyObject *resultobj = 0;
10509 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10510 wxString *arg2 = 0 ;
10511 wxFSFile *result = 0 ;
10512 void *argp1 = 0 ;
10513 int res1 = 0 ;
10514 bool temp2 = false ;
10515 PyObject * obj0 = 0 ;
10516 PyObject * obj1 = 0 ;
10517 char * kwnames[] = {
10518 (char *) "self",(char *) "location", NULL
10519 };
10520
10521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10523 if (!SWIG_IsOK(res1)) {
10524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10525 }
10526 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10527 {
10528 arg2 = wxString_in_helper(obj1);
10529 if (arg2 == NULL) SWIG_fail;
10530 temp2 = true;
10531 }
10532 {
10533 PyThreadState* __tstate = wxPyBeginAllowThreads();
10534 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10535 wxPyEndAllowThreads(__tstate);
10536 if (PyErr_Occurred()) SWIG_fail;
10537 }
10538 {
10539 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10540 }
10541 {
10542 if (temp2)
10543 delete arg2;
10544 }
10545 return resultobj;
10546 fail:
10547 {
10548 if (temp2)
10549 delete arg2;
10550 }
10551 return NULL;
10552 }
10553
10554
10555 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10556 PyObject *resultobj = 0;
10557 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10558 wxString *arg2 = 0 ;
10559 int arg3 = (int) 0 ;
10560 wxString result;
10561 void *argp1 = 0 ;
10562 int res1 = 0 ;
10563 bool temp2 = false ;
10564 int val3 ;
10565 int ecode3 = 0 ;
10566 PyObject * obj0 = 0 ;
10567 PyObject * obj1 = 0 ;
10568 PyObject * obj2 = 0 ;
10569 char * kwnames[] = {
10570 (char *) "self",(char *) "spec",(char *) "flags", NULL
10571 };
10572
10573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10575 if (!SWIG_IsOK(res1)) {
10576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10577 }
10578 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10579 {
10580 arg2 = wxString_in_helper(obj1);
10581 if (arg2 == NULL) SWIG_fail;
10582 temp2 = true;
10583 }
10584 if (obj2) {
10585 ecode3 = SWIG_AsVal_int(obj2, &val3);
10586 if (!SWIG_IsOK(ecode3)) {
10587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10588 }
10589 arg3 = static_cast< int >(val3);
10590 }
10591 {
10592 PyThreadState* __tstate = wxPyBeginAllowThreads();
10593 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10594 wxPyEndAllowThreads(__tstate);
10595 if (PyErr_Occurred()) SWIG_fail;
10596 }
10597 {
10598 #if wxUSE_UNICODE
10599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10600 #else
10601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10602 #endif
10603 }
10604 {
10605 if (temp2)
10606 delete arg2;
10607 }
10608 return resultobj;
10609 fail:
10610 {
10611 if (temp2)
10612 delete arg2;
10613 }
10614 return NULL;
10615 }
10616
10617
10618 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10619 PyObject *resultobj = 0;
10620 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10621 wxString result;
10622 void *argp1 = 0 ;
10623 int res1 = 0 ;
10624 PyObject *swig_obj[1] ;
10625
10626 if (!args) SWIG_fail;
10627 swig_obj[0] = args;
10628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10629 if (!SWIG_IsOK(res1)) {
10630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10631 }
10632 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10633 {
10634 PyThreadState* __tstate = wxPyBeginAllowThreads();
10635 result = (arg1)->FindNext();
10636 wxPyEndAllowThreads(__tstate);
10637 if (PyErr_Occurred()) SWIG_fail;
10638 }
10639 {
10640 #if wxUSE_UNICODE
10641 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10642 #else
10643 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10644 #endif
10645 }
10646 return resultobj;
10647 fail:
10648 return NULL;
10649 }
10650
10651
10652 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10653 PyObject *resultobj = 0;
10654 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10655 void *argp1 = 0 ;
10656 int res1 = 0 ;
10657 PyObject * obj0 = 0 ;
10658 char * kwnames[] = {
10659 (char *) "handler", NULL
10660 };
10661
10662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
10664 if (!SWIG_IsOK(res1)) {
10665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10666 }
10667 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10668 {
10669 PyThreadState* __tstate = wxPyBeginAllowThreads();
10670 wxFileSystem::AddHandler(arg1);
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 resultobj = SWIG_Py_Void();
10675 return resultobj;
10676 fail:
10677 return NULL;
10678 }
10679
10680
10681 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10682 PyObject *resultobj = 0;
10683
10684 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10685 {
10686 PyThreadState* __tstate = wxPyBeginAllowThreads();
10687 wxFileSystem::CleanUpHandlers();
10688 wxPyEndAllowThreads(__tstate);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 resultobj = SWIG_Py_Void();
10692 return resultobj;
10693 fail:
10694 return NULL;
10695 }
10696
10697
10698 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10699 PyObject *resultobj = 0;
10700 wxString *arg1 = 0 ;
10701 wxString result;
10702 bool temp1 = false ;
10703 PyObject * obj0 = 0 ;
10704 char * kwnames[] = {
10705 (char *) "filename", NULL
10706 };
10707
10708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10709 {
10710 arg1 = wxString_in_helper(obj0);
10711 if (arg1 == NULL) SWIG_fail;
10712 temp1 = true;
10713 }
10714 {
10715 PyThreadState* __tstate = wxPyBeginAllowThreads();
10716 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10717 wxPyEndAllowThreads(__tstate);
10718 if (PyErr_Occurred()) SWIG_fail;
10719 }
10720 {
10721 #if wxUSE_UNICODE
10722 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10723 #else
10724 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10725 #endif
10726 }
10727 {
10728 if (temp1)
10729 delete arg1;
10730 }
10731 return resultobj;
10732 fail:
10733 {
10734 if (temp1)
10735 delete arg1;
10736 }
10737 return NULL;
10738 }
10739
10740
10741 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10742 PyObject *resultobj = 0;
10743 wxString *arg1 = 0 ;
10744 wxString result;
10745 bool temp1 = false ;
10746 PyObject * obj0 = 0 ;
10747 char * kwnames[] = {
10748 (char *) "url", NULL
10749 };
10750
10751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10752 {
10753 arg1 = wxString_in_helper(obj0);
10754 if (arg1 == NULL) SWIG_fail;
10755 temp1 = true;
10756 }
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10760 wxPyEndAllowThreads(__tstate);
10761 if (PyErr_Occurred()) SWIG_fail;
10762 }
10763 {
10764 #if wxUSE_UNICODE
10765 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10766 #else
10767 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10768 #endif
10769 }
10770 {
10771 if (temp1)
10772 delete arg1;
10773 }
10774 return resultobj;
10775 fail:
10776 {
10777 if (temp1)
10778 delete arg1;
10779 }
10780 return NULL;
10781 }
10782
10783
10784 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10785 PyObject *obj;
10786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10787 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10788 return SWIG_Py_Void();
10789 }
10790
10791 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10792 return SWIG_Python_InitShadowInstance(args);
10793 }
10794
10795 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10796 PyObject *resultobj = 0;
10797 wxInternetFSHandler *result = 0 ;
10798
10799 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10800 {
10801 PyThreadState* __tstate = wxPyBeginAllowThreads();
10802 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10803 wxPyEndAllowThreads(__tstate);
10804 if (PyErr_Occurred()) SWIG_fail;
10805 }
10806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10807 return resultobj;
10808 fail:
10809 return NULL;
10810 }
10811
10812
10813 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10814 PyObject *resultobj = 0;
10815 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10816 wxString *arg2 = 0 ;
10817 bool result;
10818 void *argp1 = 0 ;
10819 int res1 = 0 ;
10820 bool temp2 = false ;
10821 PyObject * obj0 = 0 ;
10822 PyObject * obj1 = 0 ;
10823 char * kwnames[] = {
10824 (char *) "self",(char *) "location", NULL
10825 };
10826
10827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10829 if (!SWIG_IsOK(res1)) {
10830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10831 }
10832 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10833 {
10834 arg2 = wxString_in_helper(obj1);
10835 if (arg2 == NULL) SWIG_fail;
10836 temp2 = true;
10837 }
10838 {
10839 PyThreadState* __tstate = wxPyBeginAllowThreads();
10840 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10841 wxPyEndAllowThreads(__tstate);
10842 if (PyErr_Occurred()) SWIG_fail;
10843 }
10844 {
10845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10846 }
10847 {
10848 if (temp2)
10849 delete arg2;
10850 }
10851 return resultobj;
10852 fail:
10853 {
10854 if (temp2)
10855 delete arg2;
10856 }
10857 return NULL;
10858 }
10859
10860
10861 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10862 PyObject *resultobj = 0;
10863 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10864 wxFileSystem *arg2 = 0 ;
10865 wxString *arg3 = 0 ;
10866 wxFSFile *result = 0 ;
10867 void *argp1 = 0 ;
10868 int res1 = 0 ;
10869 void *argp2 = 0 ;
10870 int res2 = 0 ;
10871 bool temp3 = false ;
10872 PyObject * obj0 = 0 ;
10873 PyObject * obj1 = 0 ;
10874 PyObject * obj2 = 0 ;
10875 char * kwnames[] = {
10876 (char *) "self",(char *) "fs",(char *) "location", NULL
10877 };
10878
10879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10881 if (!SWIG_IsOK(res1)) {
10882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10883 }
10884 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10885 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10886 if (!SWIG_IsOK(res2)) {
10887 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10888 }
10889 if (!argp2) {
10890 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10891 }
10892 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10893 {
10894 arg3 = wxString_in_helper(obj2);
10895 if (arg3 == NULL) SWIG_fail;
10896 temp3 = true;
10897 }
10898 {
10899 PyThreadState* __tstate = wxPyBeginAllowThreads();
10900 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10901 wxPyEndAllowThreads(__tstate);
10902 if (PyErr_Occurred()) SWIG_fail;
10903 }
10904 {
10905 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10906 }
10907 {
10908 if (temp3)
10909 delete arg3;
10910 }
10911 return resultobj;
10912 fail:
10913 {
10914 if (temp3)
10915 delete arg3;
10916 }
10917 return NULL;
10918 }
10919
10920
10921 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10922 PyObject *obj;
10923 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10924 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
10925 return SWIG_Py_Void();
10926 }
10927
10928 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10929 return SWIG_Python_InitShadowInstance(args);
10930 }
10931
10932 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10933 PyObject *resultobj = 0;
10934 wxZipFSHandler *result = 0 ;
10935
10936 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
10937 {
10938 PyThreadState* __tstate = wxPyBeginAllowThreads();
10939 result = (wxZipFSHandler *)new wxZipFSHandler();
10940 wxPyEndAllowThreads(__tstate);
10941 if (PyErr_Occurred()) SWIG_fail;
10942 }
10943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
10944 return resultobj;
10945 fail:
10946 return NULL;
10947 }
10948
10949
10950 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10951 PyObject *resultobj = 0;
10952 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
10953 wxString *arg2 = 0 ;
10954 bool result;
10955 void *argp1 = 0 ;
10956 int res1 = 0 ;
10957 bool temp2 = false ;
10958 PyObject * obj0 = 0 ;
10959 PyObject * obj1 = 0 ;
10960 char * kwnames[] = {
10961 (char *) "self",(char *) "location", NULL
10962 };
10963
10964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
10966 if (!SWIG_IsOK(res1)) {
10967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
10968 }
10969 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
10970 {
10971 arg2 = wxString_in_helper(obj1);
10972 if (arg2 == NULL) SWIG_fail;
10973 temp2 = true;
10974 }
10975 {
10976 PyThreadState* __tstate = wxPyBeginAllowThreads();
10977 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10978 wxPyEndAllowThreads(__tstate);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 {
10982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10983 }
10984 {
10985 if (temp2)
10986 delete arg2;
10987 }
10988 return resultobj;
10989 fail:
10990 {
10991 if (temp2)
10992 delete arg2;
10993 }
10994 return NULL;
10995 }
10996
10997
10998 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10999 PyObject *resultobj = 0;
11000 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11001 wxFileSystem *arg2 = 0 ;
11002 wxString *arg3 = 0 ;
11003 wxFSFile *result = 0 ;
11004 void *argp1 = 0 ;
11005 int res1 = 0 ;
11006 void *argp2 = 0 ;
11007 int res2 = 0 ;
11008 bool temp3 = false ;
11009 PyObject * obj0 = 0 ;
11010 PyObject * obj1 = 0 ;
11011 PyObject * obj2 = 0 ;
11012 char * kwnames[] = {
11013 (char *) "self",(char *) "fs",(char *) "location", NULL
11014 };
11015
11016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11018 if (!SWIG_IsOK(res1)) {
11019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11020 }
11021 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11022 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11023 if (!SWIG_IsOK(res2)) {
11024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11025 }
11026 if (!argp2) {
11027 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11028 }
11029 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11030 {
11031 arg3 = wxString_in_helper(obj2);
11032 if (arg3 == NULL) SWIG_fail;
11033 temp3 = true;
11034 }
11035 {
11036 PyThreadState* __tstate = wxPyBeginAllowThreads();
11037 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11038 wxPyEndAllowThreads(__tstate);
11039 if (PyErr_Occurred()) SWIG_fail;
11040 }
11041 {
11042 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11043 }
11044 {
11045 if (temp3)
11046 delete arg3;
11047 }
11048 return resultobj;
11049 fail:
11050 {
11051 if (temp3)
11052 delete arg3;
11053 }
11054 return NULL;
11055 }
11056
11057
11058 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11059 PyObject *resultobj = 0;
11060 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11061 wxString *arg2 = 0 ;
11062 int arg3 = (int) 0 ;
11063 wxString result;
11064 void *argp1 = 0 ;
11065 int res1 = 0 ;
11066 bool temp2 = false ;
11067 int val3 ;
11068 int ecode3 = 0 ;
11069 PyObject * obj0 = 0 ;
11070 PyObject * obj1 = 0 ;
11071 PyObject * obj2 = 0 ;
11072 char * kwnames[] = {
11073 (char *) "self",(char *) "spec",(char *) "flags", NULL
11074 };
11075
11076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11078 if (!SWIG_IsOK(res1)) {
11079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11080 }
11081 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11082 {
11083 arg2 = wxString_in_helper(obj1);
11084 if (arg2 == NULL) SWIG_fail;
11085 temp2 = true;
11086 }
11087 if (obj2) {
11088 ecode3 = SWIG_AsVal_int(obj2, &val3);
11089 if (!SWIG_IsOK(ecode3)) {
11090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11091 }
11092 arg3 = static_cast< int >(val3);
11093 }
11094 {
11095 PyThreadState* __tstate = wxPyBeginAllowThreads();
11096 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11097 wxPyEndAllowThreads(__tstate);
11098 if (PyErr_Occurred()) SWIG_fail;
11099 }
11100 {
11101 #if wxUSE_UNICODE
11102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11103 #else
11104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11105 #endif
11106 }
11107 {
11108 if (temp2)
11109 delete arg2;
11110 }
11111 return resultobj;
11112 fail:
11113 {
11114 if (temp2)
11115 delete arg2;
11116 }
11117 return NULL;
11118 }
11119
11120
11121 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11122 PyObject *resultobj = 0;
11123 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11124 wxString result;
11125 void *argp1 = 0 ;
11126 int res1 = 0 ;
11127 PyObject *swig_obj[1] ;
11128
11129 if (!args) SWIG_fail;
11130 swig_obj[0] = args;
11131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11132 if (!SWIG_IsOK(res1)) {
11133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11134 }
11135 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11136 {
11137 PyThreadState* __tstate = wxPyBeginAllowThreads();
11138 result = (arg1)->FindNext();
11139 wxPyEndAllowThreads(__tstate);
11140 if (PyErr_Occurred()) SWIG_fail;
11141 }
11142 {
11143 #if wxUSE_UNICODE
11144 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11145 #else
11146 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11147 #endif
11148 }
11149 return resultobj;
11150 fail:
11151 return NULL;
11152 }
11153
11154
11155 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11156 PyObject *obj;
11157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11158 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11159 return SWIG_Py_Void();
11160 }
11161
11162 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11163 return SWIG_Python_InitShadowInstance(args);
11164 }
11165
11166 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11167 PyObject *resultobj = 0;
11168 wxString *arg1 = 0 ;
11169 wxImage *arg2 = 0 ;
11170 long arg3 ;
11171 bool temp1 = false ;
11172 void *argp2 = 0 ;
11173 int res2 = 0 ;
11174 long val3 ;
11175 int ecode3 = 0 ;
11176 PyObject * obj0 = 0 ;
11177 PyObject * obj1 = 0 ;
11178 PyObject * obj2 = 0 ;
11179 char * kwnames[] = {
11180 (char *) "filename",(char *) "image",(char *) "type", NULL
11181 };
11182
11183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11184 {
11185 arg1 = wxString_in_helper(obj0);
11186 if (arg1 == NULL) SWIG_fail;
11187 temp1 = true;
11188 }
11189 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11190 if (!SWIG_IsOK(res2)) {
11191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11192 }
11193 if (!argp2) {
11194 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11195 }
11196 arg2 = reinterpret_cast< wxImage * >(argp2);
11197 ecode3 = SWIG_AsVal_long(obj2, &val3);
11198 if (!SWIG_IsOK(ecode3)) {
11199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11200 }
11201 arg3 = static_cast< long >(val3);
11202 {
11203 PyThreadState* __tstate = wxPyBeginAllowThreads();
11204 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11205 wxPyEndAllowThreads(__tstate);
11206 if (PyErr_Occurred()) SWIG_fail;
11207 }
11208 resultobj = SWIG_Py_Void();
11209 {
11210 if (temp1)
11211 delete arg1;
11212 }
11213 return resultobj;
11214 fail:
11215 {
11216 if (temp1)
11217 delete arg1;
11218 }
11219 return NULL;
11220 }
11221
11222
11223 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11224 PyObject *resultobj = 0;
11225 wxString *arg1 = 0 ;
11226 wxBitmap *arg2 = 0 ;
11227 long arg3 ;
11228 bool temp1 = false ;
11229 void *argp2 = 0 ;
11230 int res2 = 0 ;
11231 long val3 ;
11232 int ecode3 = 0 ;
11233 PyObject * obj0 = 0 ;
11234 PyObject * obj1 = 0 ;
11235 PyObject * obj2 = 0 ;
11236 char * kwnames[] = {
11237 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11238 };
11239
11240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11241 {
11242 arg1 = wxString_in_helper(obj0);
11243 if (arg1 == NULL) SWIG_fail;
11244 temp1 = true;
11245 }
11246 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11247 if (!SWIG_IsOK(res2)) {
11248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11249 }
11250 if (!argp2) {
11251 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11252 }
11253 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11254 ecode3 = SWIG_AsVal_long(obj2, &val3);
11255 if (!SWIG_IsOK(ecode3)) {
11256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11257 }
11258 arg3 = static_cast< long >(val3);
11259 {
11260 PyThreadState* __tstate = wxPyBeginAllowThreads();
11261 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11262 wxPyEndAllowThreads(__tstate);
11263 if (PyErr_Occurred()) SWIG_fail;
11264 }
11265 resultobj = SWIG_Py_Void();
11266 {
11267 if (temp1)
11268 delete arg1;
11269 }
11270 return resultobj;
11271 fail:
11272 {
11273 if (temp1)
11274 delete arg1;
11275 }
11276 return NULL;
11277 }
11278
11279
11280 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11281 PyObject *resultobj = 0;
11282 wxString *arg1 = 0 ;
11283 PyObject *arg2 = (PyObject *) 0 ;
11284 bool temp1 = false ;
11285 PyObject * obj0 = 0 ;
11286 PyObject * obj1 = 0 ;
11287 char * kwnames[] = {
11288 (char *) "filename",(char *) "data", NULL
11289 };
11290
11291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11292 {
11293 arg1 = wxString_in_helper(obj0);
11294 if (arg1 == NULL) SWIG_fail;
11295 temp1 = true;
11296 }
11297 arg2 = obj1;
11298 {
11299 PyThreadState* __tstate = wxPyBeginAllowThreads();
11300 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11301 wxPyEndAllowThreads(__tstate);
11302 if (PyErr_Occurred()) SWIG_fail;
11303 }
11304 resultobj = SWIG_Py_Void();
11305 {
11306 if (temp1)
11307 delete arg1;
11308 }
11309 return resultobj;
11310 fail:
11311 {
11312 if (temp1)
11313 delete arg1;
11314 }
11315 return NULL;
11316 }
11317
11318
11319 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11320 PyObject *resultobj = 0;
11321 wxMemoryFSHandler *result = 0 ;
11322
11323 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11324 {
11325 PyThreadState* __tstate = wxPyBeginAllowThreads();
11326 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11327 wxPyEndAllowThreads(__tstate);
11328 if (PyErr_Occurred()) SWIG_fail;
11329 }
11330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11331 return resultobj;
11332 fail:
11333 return NULL;
11334 }
11335
11336
11337 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11338 PyObject *resultobj = 0;
11339 wxString *arg1 = 0 ;
11340 bool temp1 = false ;
11341 PyObject * obj0 = 0 ;
11342 char * kwnames[] = {
11343 (char *) "filename", NULL
11344 };
11345
11346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11347 {
11348 arg1 = wxString_in_helper(obj0);
11349 if (arg1 == NULL) SWIG_fail;
11350 temp1 = true;
11351 }
11352 {
11353 PyThreadState* __tstate = wxPyBeginAllowThreads();
11354 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 resultobj = SWIG_Py_Void();
11359 {
11360 if (temp1)
11361 delete arg1;
11362 }
11363 return resultobj;
11364 fail:
11365 {
11366 if (temp1)
11367 delete arg1;
11368 }
11369 return NULL;
11370 }
11371
11372
11373 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11374 PyObject *resultobj = 0;
11375 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11376 wxString *arg2 = 0 ;
11377 bool result;
11378 void *argp1 = 0 ;
11379 int res1 = 0 ;
11380 bool temp2 = false ;
11381 PyObject * obj0 = 0 ;
11382 PyObject * obj1 = 0 ;
11383 char * kwnames[] = {
11384 (char *) "self",(char *) "location", NULL
11385 };
11386
11387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11389 if (!SWIG_IsOK(res1)) {
11390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11391 }
11392 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11393 {
11394 arg2 = wxString_in_helper(obj1);
11395 if (arg2 == NULL) SWIG_fail;
11396 temp2 = true;
11397 }
11398 {
11399 PyThreadState* __tstate = wxPyBeginAllowThreads();
11400 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11401 wxPyEndAllowThreads(__tstate);
11402 if (PyErr_Occurred()) SWIG_fail;
11403 }
11404 {
11405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11406 }
11407 {
11408 if (temp2)
11409 delete arg2;
11410 }
11411 return resultobj;
11412 fail:
11413 {
11414 if (temp2)
11415 delete arg2;
11416 }
11417 return NULL;
11418 }
11419
11420
11421 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11422 PyObject *resultobj = 0;
11423 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11424 wxFileSystem *arg2 = 0 ;
11425 wxString *arg3 = 0 ;
11426 wxFSFile *result = 0 ;
11427 void *argp1 = 0 ;
11428 int res1 = 0 ;
11429 void *argp2 = 0 ;
11430 int res2 = 0 ;
11431 bool temp3 = false ;
11432 PyObject * obj0 = 0 ;
11433 PyObject * obj1 = 0 ;
11434 PyObject * obj2 = 0 ;
11435 char * kwnames[] = {
11436 (char *) "self",(char *) "fs",(char *) "location", NULL
11437 };
11438
11439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11441 if (!SWIG_IsOK(res1)) {
11442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11443 }
11444 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11445 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11446 if (!SWIG_IsOK(res2)) {
11447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11448 }
11449 if (!argp2) {
11450 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11451 }
11452 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11453 {
11454 arg3 = wxString_in_helper(obj2);
11455 if (arg3 == NULL) SWIG_fail;
11456 temp3 = true;
11457 }
11458 {
11459 PyThreadState* __tstate = wxPyBeginAllowThreads();
11460 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11461 wxPyEndAllowThreads(__tstate);
11462 if (PyErr_Occurred()) SWIG_fail;
11463 }
11464 {
11465 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11466 }
11467 {
11468 if (temp3)
11469 delete arg3;
11470 }
11471 return resultobj;
11472 fail:
11473 {
11474 if (temp3)
11475 delete arg3;
11476 }
11477 return NULL;
11478 }
11479
11480
11481 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11482 PyObject *resultobj = 0;
11483 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11484 wxString *arg2 = 0 ;
11485 int arg3 = (int) 0 ;
11486 wxString result;
11487 void *argp1 = 0 ;
11488 int res1 = 0 ;
11489 bool temp2 = false ;
11490 int val3 ;
11491 int ecode3 = 0 ;
11492 PyObject * obj0 = 0 ;
11493 PyObject * obj1 = 0 ;
11494 PyObject * obj2 = 0 ;
11495 char * kwnames[] = {
11496 (char *) "self",(char *) "spec",(char *) "flags", NULL
11497 };
11498
11499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11501 if (!SWIG_IsOK(res1)) {
11502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11503 }
11504 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11505 {
11506 arg2 = wxString_in_helper(obj1);
11507 if (arg2 == NULL) SWIG_fail;
11508 temp2 = true;
11509 }
11510 if (obj2) {
11511 ecode3 = SWIG_AsVal_int(obj2, &val3);
11512 if (!SWIG_IsOK(ecode3)) {
11513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11514 }
11515 arg3 = static_cast< int >(val3);
11516 }
11517 {
11518 PyThreadState* __tstate = wxPyBeginAllowThreads();
11519 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11520 wxPyEndAllowThreads(__tstate);
11521 if (PyErr_Occurred()) SWIG_fail;
11522 }
11523 {
11524 #if wxUSE_UNICODE
11525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11526 #else
11527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11528 #endif
11529 }
11530 {
11531 if (temp2)
11532 delete arg2;
11533 }
11534 return resultobj;
11535 fail:
11536 {
11537 if (temp2)
11538 delete arg2;
11539 }
11540 return NULL;
11541 }
11542
11543
11544 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11545 PyObject *resultobj = 0;
11546 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11547 wxString result;
11548 void *argp1 = 0 ;
11549 int res1 = 0 ;
11550 PyObject *swig_obj[1] ;
11551
11552 if (!args) SWIG_fail;
11553 swig_obj[0] = args;
11554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11555 if (!SWIG_IsOK(res1)) {
11556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11557 }
11558 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11559 {
11560 PyThreadState* __tstate = wxPyBeginAllowThreads();
11561 result = (arg1)->FindNext();
11562 wxPyEndAllowThreads(__tstate);
11563 if (PyErr_Occurred()) SWIG_fail;
11564 }
11565 {
11566 #if wxUSE_UNICODE
11567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11568 #else
11569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11570 #endif
11571 }
11572 return resultobj;
11573 fail:
11574 return NULL;
11575 }
11576
11577
11578 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11579 PyObject *obj;
11580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11581 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11582 return SWIG_Py_Void();
11583 }
11584
11585 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11586 return SWIG_Python_InitShadowInstance(args);
11587 }
11588
11589 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11590 PyObject *resultobj = 0;
11591 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11592 wxString result;
11593 void *argp1 = 0 ;
11594 int res1 = 0 ;
11595 PyObject *swig_obj[1] ;
11596
11597 if (!args) SWIG_fail;
11598 swig_obj[0] = args;
11599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11600 if (!SWIG_IsOK(res1)) {
11601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11602 }
11603 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11604 {
11605 PyThreadState* __tstate = wxPyBeginAllowThreads();
11606 result = (arg1)->GetName();
11607 wxPyEndAllowThreads(__tstate);
11608 if (PyErr_Occurred()) SWIG_fail;
11609 }
11610 {
11611 #if wxUSE_UNICODE
11612 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11613 #else
11614 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11615 #endif
11616 }
11617 return resultobj;
11618 fail:
11619 return NULL;
11620 }
11621
11622
11623 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11624 PyObject *resultobj = 0;
11625 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11626 wxString result;
11627 void *argp1 = 0 ;
11628 int res1 = 0 ;
11629 PyObject *swig_obj[1] ;
11630
11631 if (!args) SWIG_fail;
11632 swig_obj[0] = args;
11633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11634 if (!SWIG_IsOK(res1)) {
11635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11636 }
11637 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11638 {
11639 PyThreadState* __tstate = wxPyBeginAllowThreads();
11640 result = (arg1)->GetExtension();
11641 wxPyEndAllowThreads(__tstate);
11642 if (PyErr_Occurred()) SWIG_fail;
11643 }
11644 {
11645 #if wxUSE_UNICODE
11646 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11647 #else
11648 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11649 #endif
11650 }
11651 return resultobj;
11652 fail:
11653 return NULL;
11654 }
11655
11656
11657 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11658 PyObject *resultobj = 0;
11659 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11660 long result;
11661 void *argp1 = 0 ;
11662 int res1 = 0 ;
11663 PyObject *swig_obj[1] ;
11664
11665 if (!args) SWIG_fail;
11666 swig_obj[0] = args;
11667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11668 if (!SWIG_IsOK(res1)) {
11669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11670 }
11671 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11672 {
11673 PyThreadState* __tstate = wxPyBeginAllowThreads();
11674 result = (long)(arg1)->GetType();
11675 wxPyEndAllowThreads(__tstate);
11676 if (PyErr_Occurred()) SWIG_fail;
11677 }
11678 resultobj = SWIG_From_long(static_cast< long >(result));
11679 return resultobj;
11680 fail:
11681 return NULL;
11682 }
11683
11684
11685 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11686 PyObject *resultobj = 0;
11687 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11688 wxString result;
11689 void *argp1 = 0 ;
11690 int res1 = 0 ;
11691 PyObject *swig_obj[1] ;
11692
11693 if (!args) SWIG_fail;
11694 swig_obj[0] = args;
11695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11696 if (!SWIG_IsOK(res1)) {
11697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11698 }
11699 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11700 {
11701 PyThreadState* __tstate = wxPyBeginAllowThreads();
11702 result = (arg1)->GetMimeType();
11703 wxPyEndAllowThreads(__tstate);
11704 if (PyErr_Occurred()) SWIG_fail;
11705 }
11706 {
11707 #if wxUSE_UNICODE
11708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11709 #else
11710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11711 #endif
11712 }
11713 return resultobj;
11714 fail:
11715 return NULL;
11716 }
11717
11718
11719 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11720 PyObject *resultobj = 0;
11721 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11722 wxString *arg2 = 0 ;
11723 bool result;
11724 void *argp1 = 0 ;
11725 int res1 = 0 ;
11726 bool temp2 = false ;
11727 PyObject * obj0 = 0 ;
11728 PyObject * obj1 = 0 ;
11729 char * kwnames[] = {
11730 (char *) "self",(char *) "name", NULL
11731 };
11732
11733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11735 if (!SWIG_IsOK(res1)) {
11736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11737 }
11738 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11739 {
11740 arg2 = wxString_in_helper(obj1);
11741 if (arg2 == NULL) SWIG_fail;
11742 temp2 = true;
11743 }
11744 {
11745 PyThreadState* __tstate = wxPyBeginAllowThreads();
11746 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11747 wxPyEndAllowThreads(__tstate);
11748 if (PyErr_Occurred()) SWIG_fail;
11749 }
11750 {
11751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11752 }
11753 {
11754 if (temp2)
11755 delete arg2;
11756 }
11757 return resultobj;
11758 fail:
11759 {
11760 if (temp2)
11761 delete arg2;
11762 }
11763 return NULL;
11764 }
11765
11766
11767 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11768 PyObject *resultobj = 0;
11769 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11770 wxString *arg2 = 0 ;
11771 void *argp1 = 0 ;
11772 int res1 = 0 ;
11773 bool temp2 = false ;
11774 PyObject * obj0 = 0 ;
11775 PyObject * obj1 = 0 ;
11776 char * kwnames[] = {
11777 (char *) "self",(char *) "name", NULL
11778 };
11779
11780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11782 if (!SWIG_IsOK(res1)) {
11783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11784 }
11785 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11786 {
11787 arg2 = wxString_in_helper(obj1);
11788 if (arg2 == NULL) SWIG_fail;
11789 temp2 = true;
11790 }
11791 {
11792 PyThreadState* __tstate = wxPyBeginAllowThreads();
11793 (arg1)->SetName((wxString const &)*arg2);
11794 wxPyEndAllowThreads(__tstate);
11795 if (PyErr_Occurred()) SWIG_fail;
11796 }
11797 resultobj = SWIG_Py_Void();
11798 {
11799 if (temp2)
11800 delete arg2;
11801 }
11802 return resultobj;
11803 fail:
11804 {
11805 if (temp2)
11806 delete arg2;
11807 }
11808 return NULL;
11809 }
11810
11811
11812 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11813 PyObject *resultobj = 0;
11814 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11815 wxString *arg2 = 0 ;
11816 void *argp1 = 0 ;
11817 int res1 = 0 ;
11818 bool temp2 = false ;
11819 PyObject * obj0 = 0 ;
11820 PyObject * obj1 = 0 ;
11821 char * kwnames[] = {
11822 (char *) "self",(char *) "extension", NULL
11823 };
11824
11825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11827 if (!SWIG_IsOK(res1)) {
11828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11829 }
11830 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11831 {
11832 arg2 = wxString_in_helper(obj1);
11833 if (arg2 == NULL) SWIG_fail;
11834 temp2 = true;
11835 }
11836 {
11837 PyThreadState* __tstate = wxPyBeginAllowThreads();
11838 (arg1)->SetExtension((wxString const &)*arg2);
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 resultobj = SWIG_Py_Void();
11843 {
11844 if (temp2)
11845 delete arg2;
11846 }
11847 return resultobj;
11848 fail:
11849 {
11850 if (temp2)
11851 delete arg2;
11852 }
11853 return NULL;
11854 }
11855
11856
11857 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11858 PyObject *resultobj = 0;
11859 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11860 long arg2 ;
11861 void *argp1 = 0 ;
11862 int res1 = 0 ;
11863 long val2 ;
11864 int ecode2 = 0 ;
11865 PyObject * obj0 = 0 ;
11866 PyObject * obj1 = 0 ;
11867 char * kwnames[] = {
11868 (char *) "self",(char *) "type", NULL
11869 };
11870
11871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11873 if (!SWIG_IsOK(res1)) {
11874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11875 }
11876 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11877 ecode2 = SWIG_AsVal_long(obj1, &val2);
11878 if (!SWIG_IsOK(ecode2)) {
11879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11880 }
11881 arg2 = static_cast< long >(val2);
11882 {
11883 PyThreadState* __tstate = wxPyBeginAllowThreads();
11884 (arg1)->SetType(arg2);
11885 wxPyEndAllowThreads(__tstate);
11886 if (PyErr_Occurred()) SWIG_fail;
11887 }
11888 resultobj = SWIG_Py_Void();
11889 return resultobj;
11890 fail:
11891 return NULL;
11892 }
11893
11894
11895 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11896 PyObject *resultobj = 0;
11897 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11898 wxString *arg2 = 0 ;
11899 void *argp1 = 0 ;
11900 int res1 = 0 ;
11901 bool temp2 = false ;
11902 PyObject * obj0 = 0 ;
11903 PyObject * obj1 = 0 ;
11904 char * kwnames[] = {
11905 (char *) "self",(char *) "mimetype", NULL
11906 };
11907
11908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11910 if (!SWIG_IsOK(res1)) {
11911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11912 }
11913 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11914 {
11915 arg2 = wxString_in_helper(obj1);
11916 if (arg2 == NULL) SWIG_fail;
11917 temp2 = true;
11918 }
11919 {
11920 PyThreadState* __tstate = wxPyBeginAllowThreads();
11921 (arg1)->SetMimeType((wxString const &)*arg2);
11922 wxPyEndAllowThreads(__tstate);
11923 if (PyErr_Occurred()) SWIG_fail;
11924 }
11925 resultobj = SWIG_Py_Void();
11926 {
11927 if (temp2)
11928 delete arg2;
11929 }
11930 return resultobj;
11931 fail:
11932 {
11933 if (temp2)
11934 delete arg2;
11935 }
11936 return NULL;
11937 }
11938
11939
11940 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11941 PyObject *obj;
11942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11943 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
11944 return SWIG_Py_Void();
11945 }
11946
11947 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11948 PyObject *resultobj = 0;
11949 wxPyImageHandler *result = 0 ;
11950
11951 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
11952 {
11953 PyThreadState* __tstate = wxPyBeginAllowThreads();
11954 result = (wxPyImageHandler *)new wxPyImageHandler();
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
11959 return resultobj;
11960 fail:
11961 return NULL;
11962 }
11963
11964
11965 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11966 PyObject *resultobj = 0;
11967 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
11968 PyObject *arg2 = (PyObject *) 0 ;
11969 void *argp1 = 0 ;
11970 int res1 = 0 ;
11971 PyObject * obj0 = 0 ;
11972 PyObject * obj1 = 0 ;
11973 char * kwnames[] = {
11974 (char *) "self",(char *) "self", NULL
11975 };
11976
11977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
11978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
11979 if (!SWIG_IsOK(res1)) {
11980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
11981 }
11982 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
11983 arg2 = obj1;
11984 {
11985 PyThreadState* __tstate = wxPyBeginAllowThreads();
11986 (arg1)->_SetSelf(arg2);
11987 wxPyEndAllowThreads(__tstate);
11988 if (PyErr_Occurred()) SWIG_fail;
11989 }
11990 resultobj = SWIG_Py_Void();
11991 return resultobj;
11992 fail:
11993 return NULL;
11994 }
11995
11996
11997 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11998 PyObject *obj;
11999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12000 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12001 return SWIG_Py_Void();
12002 }
12003
12004 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12005 return SWIG_Python_InitShadowInstance(args);
12006 }
12007
12008 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12009 PyObject *resultobj = 0;
12010 wxImageHistogram *result = 0 ;
12011
12012 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12013 {
12014 PyThreadState* __tstate = wxPyBeginAllowThreads();
12015 result = (wxImageHistogram *)new wxImageHistogram();
12016 wxPyEndAllowThreads(__tstate);
12017 if (PyErr_Occurred()) SWIG_fail;
12018 }
12019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12020 return resultobj;
12021 fail:
12022 return NULL;
12023 }
12024
12025
12026 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12027 PyObject *resultobj = 0;
12028 byte arg1 ;
12029 byte arg2 ;
12030 byte arg3 ;
12031 unsigned long result;
12032 unsigned char val1 ;
12033 int ecode1 = 0 ;
12034 unsigned char val2 ;
12035 int ecode2 = 0 ;
12036 unsigned char val3 ;
12037 int ecode3 = 0 ;
12038 PyObject * obj0 = 0 ;
12039 PyObject * obj1 = 0 ;
12040 PyObject * obj2 = 0 ;
12041 char * kwnames[] = {
12042 (char *) "r",(char *) "g",(char *) "b", NULL
12043 };
12044
12045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12046 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12047 if (!SWIG_IsOK(ecode1)) {
12048 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12049 }
12050 arg1 = static_cast< byte >(val1);
12051 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12052 if (!SWIG_IsOK(ecode2)) {
12053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12054 }
12055 arg2 = static_cast< byte >(val2);
12056 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12057 if (!SWIG_IsOK(ecode3)) {
12058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12059 }
12060 arg3 = static_cast< byte >(val3);
12061 {
12062 PyThreadState* __tstate = wxPyBeginAllowThreads();
12063 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12064 wxPyEndAllowThreads(__tstate);
12065 if (PyErr_Occurred()) SWIG_fail;
12066 }
12067 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12068 return resultobj;
12069 fail:
12070 return NULL;
12071 }
12072
12073
12074 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12075 PyObject *resultobj = 0;
12076 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12077 byte *arg2 = (byte *) 0 ;
12078 byte *arg3 = (byte *) 0 ;
12079 byte *arg4 = (byte *) 0 ;
12080 byte arg5 = (byte) 1 ;
12081 byte arg6 = (byte) 0 ;
12082 byte arg7 = (byte) 0 ;
12083 bool result;
12084 void *argp1 = 0 ;
12085 int res1 = 0 ;
12086 byte temp2 ;
12087 int res2 = SWIG_TMPOBJ ;
12088 byte temp3 ;
12089 int res3 = SWIG_TMPOBJ ;
12090 byte temp4 ;
12091 int res4 = SWIG_TMPOBJ ;
12092 unsigned char val5 ;
12093 int ecode5 = 0 ;
12094 unsigned char val6 ;
12095 int ecode6 = 0 ;
12096 unsigned char val7 ;
12097 int ecode7 = 0 ;
12098 PyObject * obj0 = 0 ;
12099 PyObject * obj1 = 0 ;
12100 PyObject * obj2 = 0 ;
12101 PyObject * obj3 = 0 ;
12102 char * kwnames[] = {
12103 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12104 };
12105
12106 arg2 = &temp2;
12107 arg3 = &temp3;
12108 arg4 = &temp4;
12109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12111 if (!SWIG_IsOK(res1)) {
12112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12113 }
12114 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12115 if (obj1) {
12116 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12117 if (!SWIG_IsOK(ecode5)) {
12118 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12119 }
12120 arg5 = static_cast< byte >(val5);
12121 }
12122 if (obj2) {
12123 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12124 if (!SWIG_IsOK(ecode6)) {
12125 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12126 }
12127 arg6 = static_cast< byte >(val6);
12128 }
12129 if (obj3) {
12130 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12131 if (!SWIG_IsOK(ecode7)) {
12132 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12133 }
12134 arg7 = static_cast< byte >(val7);
12135 }
12136 {
12137 PyThreadState* __tstate = wxPyBeginAllowThreads();
12138 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12139 wxPyEndAllowThreads(__tstate);
12140 if (PyErr_Occurred()) SWIG_fail;
12141 }
12142 {
12143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12144 }
12145 if (SWIG_IsTmpObj(res2)) {
12146 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12147 } else {
12148 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12149 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12150 }
12151 if (SWIG_IsTmpObj(res3)) {
12152 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12153 } else {
12154 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12155 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12156 }
12157 if (SWIG_IsTmpObj(res4)) {
12158 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12159 } else {
12160 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12161 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12162 }
12163 return resultobj;
12164 fail:
12165 return NULL;
12166 }
12167
12168
12169 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12170 PyObject *resultobj = 0;
12171 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12172 unsigned long arg2 ;
12173 unsigned long result;
12174 void *argp1 = 0 ;
12175 int res1 = 0 ;
12176 unsigned long val2 ;
12177 int ecode2 = 0 ;
12178 PyObject * obj0 = 0 ;
12179 PyObject * obj1 = 0 ;
12180 char * kwnames[] = {
12181 (char *) "self",(char *) "key", NULL
12182 };
12183
12184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12186 if (!SWIG_IsOK(res1)) {
12187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12188 }
12189 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12190 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12191 if (!SWIG_IsOK(ecode2)) {
12192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12193 }
12194 arg2 = static_cast< unsigned long >(val2);
12195 {
12196 PyThreadState* __tstate = wxPyBeginAllowThreads();
12197 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12198 wxPyEndAllowThreads(__tstate);
12199 if (PyErr_Occurred()) SWIG_fail;
12200 }
12201 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12202 return resultobj;
12203 fail:
12204 return NULL;
12205 }
12206
12207
12208 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12209 PyObject *resultobj = 0;
12210 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12211 byte arg2 ;
12212 byte arg3 ;
12213 byte arg4 ;
12214 unsigned long result;
12215 void *argp1 = 0 ;
12216 int res1 = 0 ;
12217 unsigned char val2 ;
12218 int ecode2 = 0 ;
12219 unsigned char val3 ;
12220 int ecode3 = 0 ;
12221 unsigned char val4 ;
12222 int ecode4 = 0 ;
12223 PyObject * obj0 = 0 ;
12224 PyObject * obj1 = 0 ;
12225 PyObject * obj2 = 0 ;
12226 PyObject * obj3 = 0 ;
12227 char * kwnames[] = {
12228 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12229 };
12230
12231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12233 if (!SWIG_IsOK(res1)) {
12234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12235 }
12236 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12237 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12238 if (!SWIG_IsOK(ecode2)) {
12239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12240 }
12241 arg2 = static_cast< byte >(val2);
12242 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12243 if (!SWIG_IsOK(ecode3)) {
12244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12245 }
12246 arg3 = static_cast< byte >(val3);
12247 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12248 if (!SWIG_IsOK(ecode4)) {
12249 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12250 }
12251 arg4 = static_cast< byte >(val4);
12252 {
12253 PyThreadState* __tstate = wxPyBeginAllowThreads();
12254 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12255 wxPyEndAllowThreads(__tstate);
12256 if (PyErr_Occurred()) SWIG_fail;
12257 }
12258 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12259 return resultobj;
12260 fail:
12261 return NULL;
12262 }
12263
12264
12265 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12266 PyObject *resultobj = 0;
12267 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12268 wxColour *arg2 = 0 ;
12269 unsigned long result;
12270 void *argp1 = 0 ;
12271 int res1 = 0 ;
12272 wxColour temp2 ;
12273 PyObject * obj0 = 0 ;
12274 PyObject * obj1 = 0 ;
12275 char * kwnames[] = {
12276 (char *) "self",(char *) "colour", NULL
12277 };
12278
12279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12281 if (!SWIG_IsOK(res1)) {
12282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12283 }
12284 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12285 {
12286 arg2 = &temp2;
12287 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12288 }
12289 {
12290 PyThreadState* __tstate = wxPyBeginAllowThreads();
12291 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12292 wxPyEndAllowThreads(__tstate);
12293 if (PyErr_Occurred()) SWIG_fail;
12294 }
12295 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12296 return resultobj;
12297 fail:
12298 return NULL;
12299 }
12300
12301
12302 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12303 PyObject *obj;
12304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12305 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12306 return SWIG_Py_Void();
12307 }
12308
12309 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12310 return SWIG_Python_InitShadowInstance(args);
12311 }
12312
12313 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12314 PyObject *resultobj = 0;
12315 byte arg1 = (byte) 0 ;
12316 byte arg2 = (byte) 0 ;
12317 byte arg3 = (byte) 0 ;
12318 wxImage_RGBValue *result = 0 ;
12319 unsigned char val1 ;
12320 int ecode1 = 0 ;
12321 unsigned char val2 ;
12322 int ecode2 = 0 ;
12323 unsigned char val3 ;
12324 int ecode3 = 0 ;
12325 PyObject * obj0 = 0 ;
12326 PyObject * obj1 = 0 ;
12327 PyObject * obj2 = 0 ;
12328 char * kwnames[] = {
12329 (char *) "r",(char *) "g",(char *) "b", NULL
12330 };
12331
12332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12333 if (obj0) {
12334 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12335 if (!SWIG_IsOK(ecode1)) {
12336 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12337 }
12338 arg1 = static_cast< byte >(val1);
12339 }
12340 if (obj1) {
12341 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12342 if (!SWIG_IsOK(ecode2)) {
12343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12344 }
12345 arg2 = static_cast< byte >(val2);
12346 }
12347 if (obj2) {
12348 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12349 if (!SWIG_IsOK(ecode3)) {
12350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12351 }
12352 arg3 = static_cast< byte >(val3);
12353 }
12354 {
12355 PyThreadState* __tstate = wxPyBeginAllowThreads();
12356 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12357 wxPyEndAllowThreads(__tstate);
12358 if (PyErr_Occurred()) SWIG_fail;
12359 }
12360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12361 return resultobj;
12362 fail:
12363 return NULL;
12364 }
12365
12366
12367 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12368 PyObject *resultobj = 0;
12369 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12370 byte arg2 ;
12371 void *argp1 = 0 ;
12372 int res1 = 0 ;
12373 unsigned char val2 ;
12374 int ecode2 = 0 ;
12375 PyObject *swig_obj[2] ;
12376
12377 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12379 if (!SWIG_IsOK(res1)) {
12380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12381 }
12382 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12383 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12384 if (!SWIG_IsOK(ecode2)) {
12385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12386 }
12387 arg2 = static_cast< byte >(val2);
12388 if (arg1) (arg1)->red = arg2;
12389
12390 resultobj = SWIG_Py_Void();
12391 return resultobj;
12392 fail:
12393 return NULL;
12394 }
12395
12396
12397 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12398 PyObject *resultobj = 0;
12399 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12400 byte result;
12401 void *argp1 = 0 ;
12402 int res1 = 0 ;
12403 PyObject *swig_obj[1] ;
12404
12405 if (!args) SWIG_fail;
12406 swig_obj[0] = args;
12407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12408 if (!SWIG_IsOK(res1)) {
12409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12410 }
12411 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12412 result = (byte) ((arg1)->red);
12413 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12414 return resultobj;
12415 fail:
12416 return NULL;
12417 }
12418
12419
12420 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12421 PyObject *resultobj = 0;
12422 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12423 byte arg2 ;
12424 void *argp1 = 0 ;
12425 int res1 = 0 ;
12426 unsigned char val2 ;
12427 int ecode2 = 0 ;
12428 PyObject *swig_obj[2] ;
12429
12430 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12432 if (!SWIG_IsOK(res1)) {
12433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12434 }
12435 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12436 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12437 if (!SWIG_IsOK(ecode2)) {
12438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12439 }
12440 arg2 = static_cast< byte >(val2);
12441 if (arg1) (arg1)->green = arg2;
12442
12443 resultobj = SWIG_Py_Void();
12444 return resultobj;
12445 fail:
12446 return NULL;
12447 }
12448
12449
12450 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12451 PyObject *resultobj = 0;
12452 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12453 byte result;
12454 void *argp1 = 0 ;
12455 int res1 = 0 ;
12456 PyObject *swig_obj[1] ;
12457
12458 if (!args) SWIG_fail;
12459 swig_obj[0] = args;
12460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12461 if (!SWIG_IsOK(res1)) {
12462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12463 }
12464 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12465 result = (byte) ((arg1)->green);
12466 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12467 return resultobj;
12468 fail:
12469 return NULL;
12470 }
12471
12472
12473 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12474 PyObject *resultobj = 0;
12475 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12476 byte arg2 ;
12477 void *argp1 = 0 ;
12478 int res1 = 0 ;
12479 unsigned char val2 ;
12480 int ecode2 = 0 ;
12481 PyObject *swig_obj[2] ;
12482
12483 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12485 if (!SWIG_IsOK(res1)) {
12486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12487 }
12488 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12489 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12490 if (!SWIG_IsOK(ecode2)) {
12491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12492 }
12493 arg2 = static_cast< byte >(val2);
12494 if (arg1) (arg1)->blue = arg2;
12495
12496 resultobj = SWIG_Py_Void();
12497 return resultobj;
12498 fail:
12499 return NULL;
12500 }
12501
12502
12503 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12504 PyObject *resultobj = 0;
12505 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12506 byte result;
12507 void *argp1 = 0 ;
12508 int res1 = 0 ;
12509 PyObject *swig_obj[1] ;
12510
12511 if (!args) SWIG_fail;
12512 swig_obj[0] = args;
12513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12514 if (!SWIG_IsOK(res1)) {
12515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12516 }
12517 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12518 result = (byte) ((arg1)->blue);
12519 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12520 return resultobj;
12521 fail:
12522 return NULL;
12523 }
12524
12525
12526 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12527 PyObject *obj;
12528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12529 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12530 return SWIG_Py_Void();
12531 }
12532
12533 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12534 return SWIG_Python_InitShadowInstance(args);
12535 }
12536
12537 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12538 PyObject *resultobj = 0;
12539 double arg1 = (double) 0.0 ;
12540 double arg2 = (double) 0.0 ;
12541 double arg3 = (double) 0.0 ;
12542 wxImage_HSVValue *result = 0 ;
12543 double val1 ;
12544 int ecode1 = 0 ;
12545 double val2 ;
12546 int ecode2 = 0 ;
12547 double val3 ;
12548 int ecode3 = 0 ;
12549 PyObject * obj0 = 0 ;
12550 PyObject * obj1 = 0 ;
12551 PyObject * obj2 = 0 ;
12552 char * kwnames[] = {
12553 (char *) "h",(char *) "s",(char *) "v", NULL
12554 };
12555
12556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12557 if (obj0) {
12558 ecode1 = SWIG_AsVal_double(obj0, &val1);
12559 if (!SWIG_IsOK(ecode1)) {
12560 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12561 }
12562 arg1 = static_cast< double >(val1);
12563 }
12564 if (obj1) {
12565 ecode2 = SWIG_AsVal_double(obj1, &val2);
12566 if (!SWIG_IsOK(ecode2)) {
12567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12568 }
12569 arg2 = static_cast< double >(val2);
12570 }
12571 if (obj2) {
12572 ecode3 = SWIG_AsVal_double(obj2, &val3);
12573 if (!SWIG_IsOK(ecode3)) {
12574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12575 }
12576 arg3 = static_cast< double >(val3);
12577 }
12578 {
12579 PyThreadState* __tstate = wxPyBeginAllowThreads();
12580 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12581 wxPyEndAllowThreads(__tstate);
12582 if (PyErr_Occurred()) SWIG_fail;
12583 }
12584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12585 return resultobj;
12586 fail:
12587 return NULL;
12588 }
12589
12590
12591 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12592 PyObject *resultobj = 0;
12593 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12594 double arg2 ;
12595 void *argp1 = 0 ;
12596 int res1 = 0 ;
12597 double val2 ;
12598 int ecode2 = 0 ;
12599 PyObject *swig_obj[2] ;
12600
12601 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12603 if (!SWIG_IsOK(res1)) {
12604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12605 }
12606 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12607 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12608 if (!SWIG_IsOK(ecode2)) {
12609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12610 }
12611 arg2 = static_cast< double >(val2);
12612 if (arg1) (arg1)->hue = arg2;
12613
12614 resultobj = SWIG_Py_Void();
12615 return resultobj;
12616 fail:
12617 return NULL;
12618 }
12619
12620
12621 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12622 PyObject *resultobj = 0;
12623 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12624 double result;
12625 void *argp1 = 0 ;
12626 int res1 = 0 ;
12627 PyObject *swig_obj[1] ;
12628
12629 if (!args) SWIG_fail;
12630 swig_obj[0] = args;
12631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12632 if (!SWIG_IsOK(res1)) {
12633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12634 }
12635 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12636 result = (double) ((arg1)->hue);
12637 resultobj = SWIG_From_double(static_cast< double >(result));
12638 return resultobj;
12639 fail:
12640 return NULL;
12641 }
12642
12643
12644 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12645 PyObject *resultobj = 0;
12646 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12647 double arg2 ;
12648 void *argp1 = 0 ;
12649 int res1 = 0 ;
12650 double val2 ;
12651 int ecode2 = 0 ;
12652 PyObject *swig_obj[2] ;
12653
12654 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12656 if (!SWIG_IsOK(res1)) {
12657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12658 }
12659 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12660 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12661 if (!SWIG_IsOK(ecode2)) {
12662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12663 }
12664 arg2 = static_cast< double >(val2);
12665 if (arg1) (arg1)->saturation = arg2;
12666
12667 resultobj = SWIG_Py_Void();
12668 return resultobj;
12669 fail:
12670 return NULL;
12671 }
12672
12673
12674 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12675 PyObject *resultobj = 0;
12676 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12677 double result;
12678 void *argp1 = 0 ;
12679 int res1 = 0 ;
12680 PyObject *swig_obj[1] ;
12681
12682 if (!args) SWIG_fail;
12683 swig_obj[0] = args;
12684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12685 if (!SWIG_IsOK(res1)) {
12686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12687 }
12688 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12689 result = (double) ((arg1)->saturation);
12690 resultobj = SWIG_From_double(static_cast< double >(result));
12691 return resultobj;
12692 fail:
12693 return NULL;
12694 }
12695
12696
12697 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12698 PyObject *resultobj = 0;
12699 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12700 double arg2 ;
12701 void *argp1 = 0 ;
12702 int res1 = 0 ;
12703 double val2 ;
12704 int ecode2 = 0 ;
12705 PyObject *swig_obj[2] ;
12706
12707 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12709 if (!SWIG_IsOK(res1)) {
12710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12711 }
12712 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12713 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12714 if (!SWIG_IsOK(ecode2)) {
12715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12716 }
12717 arg2 = static_cast< double >(val2);
12718 if (arg1) (arg1)->value = arg2;
12719
12720 resultobj = SWIG_Py_Void();
12721 return resultobj;
12722 fail:
12723 return NULL;
12724 }
12725
12726
12727 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12728 PyObject *resultobj = 0;
12729 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12730 double result;
12731 void *argp1 = 0 ;
12732 int res1 = 0 ;
12733 PyObject *swig_obj[1] ;
12734
12735 if (!args) SWIG_fail;
12736 swig_obj[0] = args;
12737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12738 if (!SWIG_IsOK(res1)) {
12739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12740 }
12741 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12742 result = (double) ((arg1)->value);
12743 resultobj = SWIG_From_double(static_cast< double >(result));
12744 return resultobj;
12745 fail:
12746 return NULL;
12747 }
12748
12749
12750 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12751 PyObject *obj;
12752 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12753 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12754 return SWIG_Py_Void();
12755 }
12756
12757 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12758 return SWIG_Python_InitShadowInstance(args);
12759 }
12760
12761 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12762 PyObject *resultobj = 0;
12763 wxString *arg1 = 0 ;
12764 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12765 int arg3 = (int) -1 ;
12766 wxImage *result = 0 ;
12767 bool temp1 = false ;
12768 long val2 ;
12769 int ecode2 = 0 ;
12770 int val3 ;
12771 int ecode3 = 0 ;
12772 PyObject * obj0 = 0 ;
12773 PyObject * obj1 = 0 ;
12774 PyObject * obj2 = 0 ;
12775 char * kwnames[] = {
12776 (char *) "name",(char *) "type",(char *) "index", NULL
12777 };
12778
12779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12780 {
12781 arg1 = wxString_in_helper(obj0);
12782 if (arg1 == NULL) SWIG_fail;
12783 temp1 = true;
12784 }
12785 if (obj1) {
12786 ecode2 = SWIG_AsVal_long(obj1, &val2);
12787 if (!SWIG_IsOK(ecode2)) {
12788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12789 }
12790 arg2 = static_cast< long >(val2);
12791 }
12792 if (obj2) {
12793 ecode3 = SWIG_AsVal_int(obj2, &val3);
12794 if (!SWIG_IsOK(ecode3)) {
12795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12796 }
12797 arg3 = static_cast< int >(val3);
12798 }
12799 {
12800 PyThreadState* __tstate = wxPyBeginAllowThreads();
12801 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12802 wxPyEndAllowThreads(__tstate);
12803 if (PyErr_Occurred()) SWIG_fail;
12804 }
12805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12806 {
12807 if (temp1)
12808 delete arg1;
12809 }
12810 return resultobj;
12811 fail:
12812 {
12813 if (temp1)
12814 delete arg1;
12815 }
12816 return NULL;
12817 }
12818
12819
12820 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12821 PyObject *resultobj = 0;
12822 wxImage *arg1 = (wxImage *) 0 ;
12823 void *argp1 = 0 ;
12824 int res1 = 0 ;
12825 PyObject *swig_obj[1] ;
12826
12827 if (!args) SWIG_fail;
12828 swig_obj[0] = args;
12829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12830 if (!SWIG_IsOK(res1)) {
12831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12832 }
12833 arg1 = reinterpret_cast< wxImage * >(argp1);
12834 {
12835 PyThreadState* __tstate = wxPyBeginAllowThreads();
12836 delete arg1;
12837
12838 wxPyEndAllowThreads(__tstate);
12839 if (PyErr_Occurred()) SWIG_fail;
12840 }
12841 resultobj = SWIG_Py_Void();
12842 return resultobj;
12843 fail:
12844 return NULL;
12845 }
12846
12847
12848 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12849 PyObject *resultobj = 0;
12850 wxString *arg1 = 0 ;
12851 wxString *arg2 = 0 ;
12852 int arg3 = (int) -1 ;
12853 wxImage *result = 0 ;
12854 bool temp1 = false ;
12855 bool temp2 = false ;
12856 int val3 ;
12857 int ecode3 = 0 ;
12858 PyObject * obj0 = 0 ;
12859 PyObject * obj1 = 0 ;
12860 PyObject * obj2 = 0 ;
12861 char * kwnames[] = {
12862 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12863 };
12864
12865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12866 {
12867 arg1 = wxString_in_helper(obj0);
12868 if (arg1 == NULL) SWIG_fail;
12869 temp1 = true;
12870 }
12871 {
12872 arg2 = wxString_in_helper(obj1);
12873 if (arg2 == NULL) SWIG_fail;
12874 temp2 = true;
12875 }
12876 if (obj2) {
12877 ecode3 = SWIG_AsVal_int(obj2, &val3);
12878 if (!SWIG_IsOK(ecode3)) {
12879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12880 }
12881 arg3 = static_cast< int >(val3);
12882 }
12883 {
12884 PyThreadState* __tstate = wxPyBeginAllowThreads();
12885 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12886 wxPyEndAllowThreads(__tstate);
12887 if (PyErr_Occurred()) SWIG_fail;
12888 }
12889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12890 {
12891 if (temp1)
12892 delete arg1;
12893 }
12894 {
12895 if (temp2)
12896 delete arg2;
12897 }
12898 return resultobj;
12899 fail:
12900 {
12901 if (temp1)
12902 delete arg1;
12903 }
12904 {
12905 if (temp2)
12906 delete arg2;
12907 }
12908 return NULL;
12909 }
12910
12911
12912 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12913 PyObject *resultobj = 0;
12914 wxInputStream *arg1 = 0 ;
12915 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12916 int arg3 = (int) -1 ;
12917 wxImage *result = 0 ;
12918 wxPyInputStream *temp1 ;
12919 bool created1 ;
12920 long val2 ;
12921 int ecode2 = 0 ;
12922 int val3 ;
12923 int ecode3 = 0 ;
12924 PyObject * obj0 = 0 ;
12925 PyObject * obj1 = 0 ;
12926 PyObject * obj2 = 0 ;
12927 char * kwnames[] = {
12928 (char *) "stream",(char *) "type",(char *) "index", NULL
12929 };
12930
12931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12932 {
12933 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12934 arg1 = temp1->m_wxis;
12935 created1 = false;
12936 } else {
12937 PyErr_Clear(); // clear the failure of the wxPyConvert above
12938 arg1 = wxPyCBInputStream_create(obj0, false);
12939 if (arg1 == NULL) {
12940 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12941 SWIG_fail;
12942 }
12943 created1 = true;
12944 }
12945 }
12946 if (obj1) {
12947 ecode2 = SWIG_AsVal_long(obj1, &val2);
12948 if (!SWIG_IsOK(ecode2)) {
12949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
12950 }
12951 arg2 = static_cast< long >(val2);
12952 }
12953 if (obj2) {
12954 ecode3 = SWIG_AsVal_int(obj2, &val3);
12955 if (!SWIG_IsOK(ecode3)) {
12956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
12957 }
12958 arg3 = static_cast< int >(val3);
12959 }
12960 {
12961 PyThreadState* __tstate = wxPyBeginAllowThreads();
12962 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
12963 wxPyEndAllowThreads(__tstate);
12964 if (PyErr_Occurred()) SWIG_fail;
12965 }
12966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12967 {
12968 if (created1) delete arg1;
12969 }
12970 return resultobj;
12971 fail:
12972 {
12973 if (created1) delete arg1;
12974 }
12975 return NULL;
12976 }
12977
12978
12979 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12980 PyObject *resultobj = 0;
12981 wxInputStream *arg1 = 0 ;
12982 wxString *arg2 = 0 ;
12983 int arg3 = (int) -1 ;
12984 wxImage *result = 0 ;
12985 wxPyInputStream *temp1 ;
12986 bool created1 ;
12987 bool temp2 = false ;
12988 int val3 ;
12989 int ecode3 = 0 ;
12990 PyObject * obj0 = 0 ;
12991 PyObject * obj1 = 0 ;
12992 PyObject * obj2 = 0 ;
12993 char * kwnames[] = {
12994 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
12995 };
12996
12997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12998 {
12999 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13000 arg1 = temp1->m_wxis;
13001 created1 = false;
13002 } else {
13003 PyErr_Clear(); // clear the failure of the wxPyConvert above
13004 arg1 = wxPyCBInputStream_create(obj0, false);
13005 if (arg1 == NULL) {
13006 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13007 SWIG_fail;
13008 }
13009 created1 = true;
13010 }
13011 }
13012 {
13013 arg2 = wxString_in_helper(obj1);
13014 if (arg2 == NULL) SWIG_fail;
13015 temp2 = true;
13016 }
13017 if (obj2) {
13018 ecode3 = SWIG_AsVal_int(obj2, &val3);
13019 if (!SWIG_IsOK(ecode3)) {
13020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13021 }
13022 arg3 = static_cast< int >(val3);
13023 }
13024 {
13025 PyThreadState* __tstate = wxPyBeginAllowThreads();
13026 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13027 wxPyEndAllowThreads(__tstate);
13028 if (PyErr_Occurred()) SWIG_fail;
13029 }
13030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13031 {
13032 if (created1) delete arg1;
13033 }
13034 {
13035 if (temp2)
13036 delete arg2;
13037 }
13038 return resultobj;
13039 fail:
13040 {
13041 if (created1) delete arg1;
13042 }
13043 {
13044 if (temp2)
13045 delete arg2;
13046 }
13047 return NULL;
13048 }
13049
13050
13051 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13052 PyObject *resultobj = 0;
13053 int arg1 = (int) 0 ;
13054 int arg2 = (int) 0 ;
13055 bool arg3 = (bool) true ;
13056 wxImage *result = 0 ;
13057 int val1 ;
13058 int ecode1 = 0 ;
13059 int val2 ;
13060 int ecode2 = 0 ;
13061 bool val3 ;
13062 int ecode3 = 0 ;
13063 PyObject * obj0 = 0 ;
13064 PyObject * obj1 = 0 ;
13065 PyObject * obj2 = 0 ;
13066 char * kwnames[] = {
13067 (char *) "width",(char *) "height",(char *) "clear", NULL
13068 };
13069
13070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13071 if (obj0) {
13072 ecode1 = SWIG_AsVal_int(obj0, &val1);
13073 if (!SWIG_IsOK(ecode1)) {
13074 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13075 }
13076 arg1 = static_cast< int >(val1);
13077 }
13078 if (obj1) {
13079 ecode2 = SWIG_AsVal_int(obj1, &val2);
13080 if (!SWIG_IsOK(ecode2)) {
13081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13082 }
13083 arg2 = static_cast< int >(val2);
13084 }
13085 if (obj2) {
13086 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13087 if (!SWIG_IsOK(ecode3)) {
13088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13089 }
13090 arg3 = static_cast< bool >(val3);
13091 }
13092 {
13093 PyThreadState* __tstate = wxPyBeginAllowThreads();
13094 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13095 wxPyEndAllowThreads(__tstate);
13096 if (PyErr_Occurred()) SWIG_fail;
13097 }
13098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13099 return resultobj;
13100 fail:
13101 return NULL;
13102 }
13103
13104
13105 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13106 PyObject *resultobj = 0;
13107 wxBitmap *arg1 = 0 ;
13108 wxImage *result = 0 ;
13109 void *argp1 = 0 ;
13110 int res1 = 0 ;
13111 PyObject * obj0 = 0 ;
13112 char * kwnames[] = {
13113 (char *) "bitmap", NULL
13114 };
13115
13116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13117 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13118 if (!SWIG_IsOK(res1)) {
13119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13120 }
13121 if (!argp1) {
13122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13123 }
13124 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13125 {
13126 if (!wxPyCheckForApp()) SWIG_fail;
13127 PyThreadState* __tstate = wxPyBeginAllowThreads();
13128 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13129 wxPyEndAllowThreads(__tstate);
13130 if (PyErr_Occurred()) SWIG_fail;
13131 }
13132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13140 PyObject *resultobj = 0;
13141 int arg1 ;
13142 int arg2 ;
13143 buffer arg3 ;
13144 int arg4 ;
13145 wxImage *result = 0 ;
13146 int val1 ;
13147 int ecode1 = 0 ;
13148 int val2 ;
13149 int ecode2 = 0 ;
13150 PyObject * obj0 = 0 ;
13151 PyObject * obj1 = 0 ;
13152 PyObject * obj2 = 0 ;
13153 char * kwnames[] = {
13154 (char *) "width",(char *) "height",(char *) "data", NULL
13155 };
13156
13157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13158 ecode1 = SWIG_AsVal_int(obj0, &val1);
13159 if (!SWIG_IsOK(ecode1)) {
13160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13161 }
13162 arg1 = static_cast< int >(val1);
13163 ecode2 = SWIG_AsVal_int(obj1, &val2);
13164 if (!SWIG_IsOK(ecode2)) {
13165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13166 }
13167 arg2 = static_cast< int >(val2);
13168 {
13169 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13170 }
13171 {
13172 PyThreadState* __tstate = wxPyBeginAllowThreads();
13173 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13174 wxPyEndAllowThreads(__tstate);
13175 if (PyErr_Occurred()) SWIG_fail;
13176 }
13177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13178 return resultobj;
13179 fail:
13180 return NULL;
13181 }
13182
13183
13184 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13185 PyObject *resultobj = 0;
13186 int arg1 ;
13187 int arg2 ;
13188 buffer arg3 ;
13189 int arg4 ;
13190 buffer arg5 ;
13191 int arg6 ;
13192 wxImage *result = 0 ;
13193 int val1 ;
13194 int ecode1 = 0 ;
13195 int val2 ;
13196 int ecode2 = 0 ;
13197 PyObject * obj0 = 0 ;
13198 PyObject * obj1 = 0 ;
13199 PyObject * obj2 = 0 ;
13200 PyObject * obj3 = 0 ;
13201 char * kwnames[] = {
13202 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13203 };
13204
13205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13206 ecode1 = SWIG_AsVal_int(obj0, &val1);
13207 if (!SWIG_IsOK(ecode1)) {
13208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13209 }
13210 arg1 = static_cast< int >(val1);
13211 ecode2 = SWIG_AsVal_int(obj1, &val2);
13212 if (!SWIG_IsOK(ecode2)) {
13213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13214 }
13215 arg2 = static_cast< int >(val2);
13216 {
13217 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13218 }
13219 {
13220 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13221 }
13222 {
13223 PyThreadState* __tstate = wxPyBeginAllowThreads();
13224 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13225 wxPyEndAllowThreads(__tstate);
13226 if (PyErr_Occurred()) SWIG_fail;
13227 }
13228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13229 return resultobj;
13230 fail:
13231 return NULL;
13232 }
13233
13234
13235 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13236 PyObject *resultobj = 0;
13237 wxImage *arg1 = (wxImage *) 0 ;
13238 int arg2 ;
13239 int arg3 ;
13240 bool arg4 = (bool) true ;
13241 void *argp1 = 0 ;
13242 int res1 = 0 ;
13243 int val2 ;
13244 int ecode2 = 0 ;
13245 int val3 ;
13246 int ecode3 = 0 ;
13247 bool val4 ;
13248 int ecode4 = 0 ;
13249 PyObject * obj0 = 0 ;
13250 PyObject * obj1 = 0 ;
13251 PyObject * obj2 = 0 ;
13252 PyObject * obj3 = 0 ;
13253 char * kwnames[] = {
13254 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13255 };
13256
13257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13259 if (!SWIG_IsOK(res1)) {
13260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13261 }
13262 arg1 = reinterpret_cast< wxImage * >(argp1);
13263 ecode2 = SWIG_AsVal_int(obj1, &val2);
13264 if (!SWIG_IsOK(ecode2)) {
13265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13266 }
13267 arg2 = static_cast< int >(val2);
13268 ecode3 = SWIG_AsVal_int(obj2, &val3);
13269 if (!SWIG_IsOK(ecode3)) {
13270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13271 }
13272 arg3 = static_cast< int >(val3);
13273 if (obj3) {
13274 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13275 if (!SWIG_IsOK(ecode4)) {
13276 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13277 }
13278 arg4 = static_cast< bool >(val4);
13279 }
13280 {
13281 PyThreadState* __tstate = wxPyBeginAllowThreads();
13282 (arg1)->Create(arg2,arg3,arg4);
13283 wxPyEndAllowThreads(__tstate);
13284 if (PyErr_Occurred()) SWIG_fail;
13285 }
13286 resultobj = SWIG_Py_Void();
13287 return resultobj;
13288 fail:
13289 return NULL;
13290 }
13291
13292
13293 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13294 PyObject *resultobj = 0;
13295 wxImage *arg1 = (wxImage *) 0 ;
13296 void *argp1 = 0 ;
13297 int res1 = 0 ;
13298 PyObject *swig_obj[1] ;
13299
13300 if (!args) SWIG_fail;
13301 swig_obj[0] = args;
13302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13303 if (!SWIG_IsOK(res1)) {
13304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13305 }
13306 arg1 = reinterpret_cast< wxImage * >(argp1);
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 (arg1)->Destroy();
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 resultobj = SWIG_Py_Void();
13314 return resultobj;
13315 fail:
13316 return NULL;
13317 }
13318
13319
13320 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13321 PyObject *resultobj = 0;
13322 wxImage *arg1 = (wxImage *) 0 ;
13323 int arg2 ;
13324 int arg3 ;
13325 SwigValueWrapper<wxImage > result;
13326 void *argp1 = 0 ;
13327 int res1 = 0 ;
13328 int val2 ;
13329 int ecode2 = 0 ;
13330 int val3 ;
13331 int ecode3 = 0 ;
13332 PyObject * obj0 = 0 ;
13333 PyObject * obj1 = 0 ;
13334 PyObject * obj2 = 0 ;
13335 char * kwnames[] = {
13336 (char *) "self",(char *) "width",(char *) "height", NULL
13337 };
13338
13339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13341 if (!SWIG_IsOK(res1)) {
13342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13343 }
13344 arg1 = reinterpret_cast< wxImage * >(argp1);
13345 ecode2 = SWIG_AsVal_int(obj1, &val2);
13346 if (!SWIG_IsOK(ecode2)) {
13347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13348 }
13349 arg2 = static_cast< int >(val2);
13350 ecode3 = SWIG_AsVal_int(obj2, &val3);
13351 if (!SWIG_IsOK(ecode3)) {
13352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13353 }
13354 arg3 = static_cast< int >(val3);
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 result = (arg1)->Scale(arg2,arg3);
13358 wxPyEndAllowThreads(__tstate);
13359 if (PyErr_Occurred()) SWIG_fail;
13360 }
13361 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13362 return resultobj;
13363 fail:
13364 return NULL;
13365 }
13366
13367
13368 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13369 PyObject *resultobj = 0;
13370 wxImage *arg1 = (wxImage *) 0 ;
13371 int arg2 ;
13372 int arg3 ;
13373 SwigValueWrapper<wxImage > result;
13374 void *argp1 = 0 ;
13375 int res1 = 0 ;
13376 int val2 ;
13377 int ecode2 = 0 ;
13378 int val3 ;
13379 int ecode3 = 0 ;
13380 PyObject * obj0 = 0 ;
13381 PyObject * obj1 = 0 ;
13382 PyObject * obj2 = 0 ;
13383 char * kwnames[] = {
13384 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13385 };
13386
13387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13389 if (!SWIG_IsOK(res1)) {
13390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13391 }
13392 arg1 = reinterpret_cast< wxImage * >(argp1);
13393 ecode2 = SWIG_AsVal_int(obj1, &val2);
13394 if (!SWIG_IsOK(ecode2)) {
13395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13396 }
13397 arg2 = static_cast< int >(val2);
13398 ecode3 = SWIG_AsVal_int(obj2, &val3);
13399 if (!SWIG_IsOK(ecode3)) {
13400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13401 }
13402 arg3 = static_cast< int >(val3);
13403 {
13404 PyThreadState* __tstate = wxPyBeginAllowThreads();
13405 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13406 wxPyEndAllowThreads(__tstate);
13407 if (PyErr_Occurred()) SWIG_fail;
13408 }
13409 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13410 return resultobj;
13411 fail:
13412 return NULL;
13413 }
13414
13415
13416 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13417 PyObject *resultobj = 0;
13418 wxImage *arg1 = (wxImage *) 0 ;
13419 int arg2 ;
13420 int arg3 ;
13421 wxImage *result = 0 ;
13422 void *argp1 = 0 ;
13423 int res1 = 0 ;
13424 int val2 ;
13425 int ecode2 = 0 ;
13426 int val3 ;
13427 int ecode3 = 0 ;
13428 PyObject * obj0 = 0 ;
13429 PyObject * obj1 = 0 ;
13430 PyObject * obj2 = 0 ;
13431 char * kwnames[] = {
13432 (char *) "self",(char *) "width",(char *) "height", NULL
13433 };
13434
13435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13437 if (!SWIG_IsOK(res1)) {
13438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13439 }
13440 arg1 = reinterpret_cast< wxImage * >(argp1);
13441 ecode2 = SWIG_AsVal_int(obj1, &val2);
13442 if (!SWIG_IsOK(ecode2)) {
13443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13444 }
13445 arg2 = static_cast< int >(val2);
13446 ecode3 = SWIG_AsVal_int(obj2, &val3);
13447 if (!SWIG_IsOK(ecode3)) {
13448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13449 }
13450 arg3 = static_cast< int >(val3);
13451 {
13452 PyThreadState* __tstate = wxPyBeginAllowThreads();
13453 {
13454 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13455 result = (wxImage *) &_result_ref;
13456 }
13457 wxPyEndAllowThreads(__tstate);
13458 if (PyErr_Occurred()) SWIG_fail;
13459 }
13460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13461 return resultobj;
13462 fail:
13463 return NULL;
13464 }
13465
13466
13467 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13468 PyObject *resultobj = 0;
13469 wxImage *arg1 = (wxImage *) 0 ;
13470 wxSize *arg2 = 0 ;
13471 wxPoint *arg3 = 0 ;
13472 int arg4 = (int) -1 ;
13473 int arg5 = (int) -1 ;
13474 int arg6 = (int) -1 ;
13475 wxImage *result = 0 ;
13476 void *argp1 = 0 ;
13477 int res1 = 0 ;
13478 wxSize temp2 ;
13479 wxPoint temp3 ;
13480 int val4 ;
13481 int ecode4 = 0 ;
13482 int val5 ;
13483 int ecode5 = 0 ;
13484 int val6 ;
13485 int ecode6 = 0 ;
13486 PyObject * obj0 = 0 ;
13487 PyObject * obj1 = 0 ;
13488 PyObject * obj2 = 0 ;
13489 PyObject * obj3 = 0 ;
13490 PyObject * obj4 = 0 ;
13491 PyObject * obj5 = 0 ;
13492 char * kwnames[] = {
13493 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13494 };
13495
13496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13498 if (!SWIG_IsOK(res1)) {
13499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13500 }
13501 arg1 = reinterpret_cast< wxImage * >(argp1);
13502 {
13503 arg2 = &temp2;
13504 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13505 }
13506 {
13507 arg3 = &temp3;
13508 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13509 }
13510 if (obj3) {
13511 ecode4 = SWIG_AsVal_int(obj3, &val4);
13512 if (!SWIG_IsOK(ecode4)) {
13513 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13514 }
13515 arg4 = static_cast< int >(val4);
13516 }
13517 if (obj4) {
13518 ecode5 = SWIG_AsVal_int(obj4, &val5);
13519 if (!SWIG_IsOK(ecode5)) {
13520 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13521 }
13522 arg5 = static_cast< int >(val5);
13523 }
13524 if (obj5) {
13525 ecode6 = SWIG_AsVal_int(obj5, &val6);
13526 if (!SWIG_IsOK(ecode6)) {
13527 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13528 }
13529 arg6 = static_cast< int >(val6);
13530 }
13531 {
13532 PyThreadState* __tstate = wxPyBeginAllowThreads();
13533 {
13534 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13535 result = (wxImage *) &_result_ref;
13536 }
13537 wxPyEndAllowThreads(__tstate);
13538 if (PyErr_Occurred()) SWIG_fail;
13539 }
13540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13541 return resultobj;
13542 fail:
13543 return NULL;
13544 }
13545
13546
13547 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13548 PyObject *resultobj = 0;
13549 wxImage *arg1 = (wxImage *) 0 ;
13550 int arg2 ;
13551 int arg3 ;
13552 byte arg4 ;
13553 byte arg5 ;
13554 byte arg6 ;
13555 void *argp1 = 0 ;
13556 int res1 = 0 ;
13557 int val2 ;
13558 int ecode2 = 0 ;
13559 int val3 ;
13560 int ecode3 = 0 ;
13561 unsigned char val4 ;
13562 int ecode4 = 0 ;
13563 unsigned char val5 ;
13564 int ecode5 = 0 ;
13565 unsigned char val6 ;
13566 int ecode6 = 0 ;
13567 PyObject * obj0 = 0 ;
13568 PyObject * obj1 = 0 ;
13569 PyObject * obj2 = 0 ;
13570 PyObject * obj3 = 0 ;
13571 PyObject * obj4 = 0 ;
13572 PyObject * obj5 = 0 ;
13573 char * kwnames[] = {
13574 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13575 };
13576
13577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13579 if (!SWIG_IsOK(res1)) {
13580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13581 }
13582 arg1 = reinterpret_cast< wxImage * >(argp1);
13583 ecode2 = SWIG_AsVal_int(obj1, &val2);
13584 if (!SWIG_IsOK(ecode2)) {
13585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13586 }
13587 arg2 = static_cast< int >(val2);
13588 ecode3 = SWIG_AsVal_int(obj2, &val3);
13589 if (!SWIG_IsOK(ecode3)) {
13590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13591 }
13592 arg3 = static_cast< int >(val3);
13593 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13594 if (!SWIG_IsOK(ecode4)) {
13595 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13596 }
13597 arg4 = static_cast< byte >(val4);
13598 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13599 if (!SWIG_IsOK(ecode5)) {
13600 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13601 }
13602 arg5 = static_cast< byte >(val5);
13603 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13604 if (!SWIG_IsOK(ecode6)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13606 }
13607 arg6 = static_cast< byte >(val6);
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13611 wxPyEndAllowThreads(__tstate);
13612 if (PyErr_Occurred()) SWIG_fail;
13613 }
13614 resultobj = SWIG_Py_Void();
13615 return resultobj;
13616 fail:
13617 return NULL;
13618 }
13619
13620
13621 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13622 PyObject *resultobj = 0;
13623 wxImage *arg1 = (wxImage *) 0 ;
13624 wxRect *arg2 = 0 ;
13625 byte arg3 ;
13626 byte arg4 ;
13627 byte arg5 ;
13628 void *argp1 = 0 ;
13629 int res1 = 0 ;
13630 wxRect temp2 ;
13631 unsigned char val3 ;
13632 int ecode3 = 0 ;
13633 unsigned char val4 ;
13634 int ecode4 = 0 ;
13635 unsigned char val5 ;
13636 int ecode5 = 0 ;
13637 PyObject * obj0 = 0 ;
13638 PyObject * obj1 = 0 ;
13639 PyObject * obj2 = 0 ;
13640 PyObject * obj3 = 0 ;
13641 PyObject * obj4 = 0 ;
13642 char * kwnames[] = {
13643 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13644 };
13645
13646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13648 if (!SWIG_IsOK(res1)) {
13649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13650 }
13651 arg1 = reinterpret_cast< wxImage * >(argp1);
13652 {
13653 arg2 = &temp2;
13654 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13655 }
13656 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13657 if (!SWIG_IsOK(ecode3)) {
13658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13659 }
13660 arg3 = static_cast< byte >(val3);
13661 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13662 if (!SWIG_IsOK(ecode4)) {
13663 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13664 }
13665 arg4 = static_cast< byte >(val4);
13666 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13667 if (!SWIG_IsOK(ecode5)) {
13668 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13669 }
13670 arg5 = static_cast< byte >(val5);
13671 {
13672 PyThreadState* __tstate = wxPyBeginAllowThreads();
13673 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13674 wxPyEndAllowThreads(__tstate);
13675 if (PyErr_Occurred()) SWIG_fail;
13676 }
13677 resultobj = SWIG_Py_Void();
13678 return resultobj;
13679 fail:
13680 return NULL;
13681 }
13682
13683
13684 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13685 PyObject *resultobj = 0;
13686 wxImage *arg1 = (wxImage *) 0 ;
13687 int arg2 ;
13688 int arg3 ;
13689 byte result;
13690 void *argp1 = 0 ;
13691 int res1 = 0 ;
13692 int val2 ;
13693 int ecode2 = 0 ;
13694 int val3 ;
13695 int ecode3 = 0 ;
13696 PyObject * obj0 = 0 ;
13697 PyObject * obj1 = 0 ;
13698 PyObject * obj2 = 0 ;
13699 char * kwnames[] = {
13700 (char *) "self",(char *) "x",(char *) "y", NULL
13701 };
13702
13703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13705 if (!SWIG_IsOK(res1)) {
13706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13707 }
13708 arg1 = reinterpret_cast< wxImage * >(argp1);
13709 ecode2 = SWIG_AsVal_int(obj1, &val2);
13710 if (!SWIG_IsOK(ecode2)) {
13711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13712 }
13713 arg2 = static_cast< int >(val2);
13714 ecode3 = SWIG_AsVal_int(obj2, &val3);
13715 if (!SWIG_IsOK(ecode3)) {
13716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13717 }
13718 arg3 = static_cast< int >(val3);
13719 {
13720 PyThreadState* __tstate = wxPyBeginAllowThreads();
13721 result = (byte)(arg1)->GetRed(arg2,arg3);
13722 wxPyEndAllowThreads(__tstate);
13723 if (PyErr_Occurred()) SWIG_fail;
13724 }
13725 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13726 return resultobj;
13727 fail:
13728 return NULL;
13729 }
13730
13731
13732 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13733 PyObject *resultobj = 0;
13734 wxImage *arg1 = (wxImage *) 0 ;
13735 int arg2 ;
13736 int arg3 ;
13737 byte result;
13738 void *argp1 = 0 ;
13739 int res1 = 0 ;
13740 int val2 ;
13741 int ecode2 = 0 ;
13742 int val3 ;
13743 int ecode3 = 0 ;
13744 PyObject * obj0 = 0 ;
13745 PyObject * obj1 = 0 ;
13746 PyObject * obj2 = 0 ;
13747 char * kwnames[] = {
13748 (char *) "self",(char *) "x",(char *) "y", NULL
13749 };
13750
13751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13753 if (!SWIG_IsOK(res1)) {
13754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13755 }
13756 arg1 = reinterpret_cast< wxImage * >(argp1);
13757 ecode2 = SWIG_AsVal_int(obj1, &val2);
13758 if (!SWIG_IsOK(ecode2)) {
13759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13760 }
13761 arg2 = static_cast< int >(val2);
13762 ecode3 = SWIG_AsVal_int(obj2, &val3);
13763 if (!SWIG_IsOK(ecode3)) {
13764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13765 }
13766 arg3 = static_cast< int >(val3);
13767 {
13768 PyThreadState* __tstate = wxPyBeginAllowThreads();
13769 result = (byte)(arg1)->GetGreen(arg2,arg3);
13770 wxPyEndAllowThreads(__tstate);
13771 if (PyErr_Occurred()) SWIG_fail;
13772 }
13773 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13774 return resultobj;
13775 fail:
13776 return NULL;
13777 }
13778
13779
13780 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13781 PyObject *resultobj = 0;
13782 wxImage *arg1 = (wxImage *) 0 ;
13783 int arg2 ;
13784 int arg3 ;
13785 byte result;
13786 void *argp1 = 0 ;
13787 int res1 = 0 ;
13788 int val2 ;
13789 int ecode2 = 0 ;
13790 int val3 ;
13791 int ecode3 = 0 ;
13792 PyObject * obj0 = 0 ;
13793 PyObject * obj1 = 0 ;
13794 PyObject * obj2 = 0 ;
13795 char * kwnames[] = {
13796 (char *) "self",(char *) "x",(char *) "y", NULL
13797 };
13798
13799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13801 if (!SWIG_IsOK(res1)) {
13802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13803 }
13804 arg1 = reinterpret_cast< wxImage * >(argp1);
13805 ecode2 = SWIG_AsVal_int(obj1, &val2);
13806 if (!SWIG_IsOK(ecode2)) {
13807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13808 }
13809 arg2 = static_cast< int >(val2);
13810 ecode3 = SWIG_AsVal_int(obj2, &val3);
13811 if (!SWIG_IsOK(ecode3)) {
13812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13813 }
13814 arg3 = static_cast< int >(val3);
13815 {
13816 PyThreadState* __tstate = wxPyBeginAllowThreads();
13817 result = (byte)(arg1)->GetBlue(arg2,arg3);
13818 wxPyEndAllowThreads(__tstate);
13819 if (PyErr_Occurred()) SWIG_fail;
13820 }
13821 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13822 return resultobj;
13823 fail:
13824 return NULL;
13825 }
13826
13827
13828 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13829 PyObject *resultobj = 0;
13830 wxImage *arg1 = (wxImage *) 0 ;
13831 int arg2 ;
13832 int arg3 ;
13833 byte arg4 ;
13834 void *argp1 = 0 ;
13835 int res1 = 0 ;
13836 int val2 ;
13837 int ecode2 = 0 ;
13838 int val3 ;
13839 int ecode3 = 0 ;
13840 unsigned char val4 ;
13841 int ecode4 = 0 ;
13842 PyObject * obj0 = 0 ;
13843 PyObject * obj1 = 0 ;
13844 PyObject * obj2 = 0 ;
13845 PyObject * obj3 = 0 ;
13846 char * kwnames[] = {
13847 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13848 };
13849
13850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13852 if (!SWIG_IsOK(res1)) {
13853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13854 }
13855 arg1 = reinterpret_cast< wxImage * >(argp1);
13856 ecode2 = SWIG_AsVal_int(obj1, &val2);
13857 if (!SWIG_IsOK(ecode2)) {
13858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13859 }
13860 arg2 = static_cast< int >(val2);
13861 ecode3 = SWIG_AsVal_int(obj2, &val3);
13862 if (!SWIG_IsOK(ecode3)) {
13863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13864 }
13865 arg3 = static_cast< int >(val3);
13866 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13867 if (!SWIG_IsOK(ecode4)) {
13868 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13869 }
13870 arg4 = static_cast< byte >(val4);
13871 {
13872 PyThreadState* __tstate = wxPyBeginAllowThreads();
13873 (arg1)->SetAlpha(arg2,arg3,arg4);
13874 wxPyEndAllowThreads(__tstate);
13875 if (PyErr_Occurred()) SWIG_fail;
13876 }
13877 resultobj = SWIG_Py_Void();
13878 return resultobj;
13879 fail:
13880 return NULL;
13881 }
13882
13883
13884 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13885 PyObject *resultobj = 0;
13886 wxImage *arg1 = (wxImage *) 0 ;
13887 int arg2 ;
13888 int arg3 ;
13889 byte result;
13890 void *argp1 = 0 ;
13891 int res1 = 0 ;
13892 int val2 ;
13893 int ecode2 = 0 ;
13894 int val3 ;
13895 int ecode3 = 0 ;
13896 PyObject * obj0 = 0 ;
13897 PyObject * obj1 = 0 ;
13898 PyObject * obj2 = 0 ;
13899 char * kwnames[] = {
13900 (char *) "self",(char *) "x",(char *) "y", NULL
13901 };
13902
13903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13905 if (!SWIG_IsOK(res1)) {
13906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13907 }
13908 arg1 = reinterpret_cast< wxImage * >(argp1);
13909 ecode2 = SWIG_AsVal_int(obj1, &val2);
13910 if (!SWIG_IsOK(ecode2)) {
13911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13912 }
13913 arg2 = static_cast< int >(val2);
13914 ecode3 = SWIG_AsVal_int(obj2, &val3);
13915 if (!SWIG_IsOK(ecode3)) {
13916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
13917 }
13918 arg3 = static_cast< int >(val3);
13919 {
13920 PyThreadState* __tstate = wxPyBeginAllowThreads();
13921 result = (byte)(arg1)->GetAlpha(arg2,arg3);
13922 wxPyEndAllowThreads(__tstate);
13923 if (PyErr_Occurred()) SWIG_fail;
13924 }
13925 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13926 return resultobj;
13927 fail:
13928 return NULL;
13929 }
13930
13931
13932 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13933 PyObject *resultobj = 0;
13934 wxImage *arg1 = (wxImage *) 0 ;
13935 bool result;
13936 void *argp1 = 0 ;
13937 int res1 = 0 ;
13938 PyObject *swig_obj[1] ;
13939
13940 if (!args) SWIG_fail;
13941 swig_obj[0] = args;
13942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13943 if (!SWIG_IsOK(res1)) {
13944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13945 }
13946 arg1 = reinterpret_cast< wxImage * >(argp1);
13947 {
13948 PyThreadState* __tstate = wxPyBeginAllowThreads();
13949 result = (bool)(arg1)->HasAlpha();
13950 wxPyEndAllowThreads(__tstate);
13951 if (PyErr_Occurred()) SWIG_fail;
13952 }
13953 {
13954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13955 }
13956 return resultobj;
13957 fail:
13958 return NULL;
13959 }
13960
13961
13962 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13963 PyObject *resultobj = 0;
13964 wxImage *arg1 = (wxImage *) 0 ;
13965 void *argp1 = 0 ;
13966 int res1 = 0 ;
13967 PyObject *swig_obj[1] ;
13968
13969 if (!args) SWIG_fail;
13970 swig_obj[0] = args;
13971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13972 if (!SWIG_IsOK(res1)) {
13973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13974 }
13975 arg1 = reinterpret_cast< wxImage * >(argp1);
13976 {
13977 PyThreadState* __tstate = wxPyBeginAllowThreads();
13978 (arg1)->InitAlpha();
13979 wxPyEndAllowThreads(__tstate);
13980 if (PyErr_Occurred()) SWIG_fail;
13981 }
13982 resultobj = SWIG_Py_Void();
13983 return resultobj;
13984 fail:
13985 return NULL;
13986 }
13987
13988
13989 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13990 PyObject *resultobj = 0;
13991 wxImage *arg1 = (wxImage *) 0 ;
13992 int arg2 ;
13993 int arg3 ;
13994 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
13995 bool result;
13996 void *argp1 = 0 ;
13997 int res1 = 0 ;
13998 int val2 ;
13999 int ecode2 = 0 ;
14000 int val3 ;
14001 int ecode3 = 0 ;
14002 unsigned char val4 ;
14003 int ecode4 = 0 ;
14004 PyObject * obj0 = 0 ;
14005 PyObject * obj1 = 0 ;
14006 PyObject * obj2 = 0 ;
14007 PyObject * obj3 = 0 ;
14008 char * kwnames[] = {
14009 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14010 };
14011
14012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14014 if (!SWIG_IsOK(res1)) {
14015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14016 }
14017 arg1 = reinterpret_cast< wxImage * >(argp1);
14018 ecode2 = SWIG_AsVal_int(obj1, &val2);
14019 if (!SWIG_IsOK(ecode2)) {
14020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14021 }
14022 arg2 = static_cast< int >(val2);
14023 ecode3 = SWIG_AsVal_int(obj2, &val3);
14024 if (!SWIG_IsOK(ecode3)) {
14025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14026 }
14027 arg3 = static_cast< int >(val3);
14028 if (obj3) {
14029 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14030 if (!SWIG_IsOK(ecode4)) {
14031 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14032 }
14033 arg4 = static_cast< byte >(val4);
14034 }
14035 {
14036 PyThreadState* __tstate = wxPyBeginAllowThreads();
14037 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14038 wxPyEndAllowThreads(__tstate);
14039 if (PyErr_Occurred()) SWIG_fail;
14040 }
14041 {
14042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14043 }
14044 return resultobj;
14045 fail:
14046 return NULL;
14047 }
14048
14049
14050 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14051 PyObject *resultobj = 0;
14052 wxImage *arg1 = (wxImage *) 0 ;
14053 byte *arg2 = (byte *) 0 ;
14054 byte *arg3 = (byte *) 0 ;
14055 byte *arg4 = (byte *) 0 ;
14056 byte arg5 = (byte) 0 ;
14057 byte arg6 = (byte) 0 ;
14058 byte arg7 = (byte) 0 ;
14059 bool result;
14060 void *argp1 = 0 ;
14061 int res1 = 0 ;
14062 byte temp2 ;
14063 int res2 = SWIG_TMPOBJ ;
14064 byte temp3 ;
14065 int res3 = SWIG_TMPOBJ ;
14066 byte temp4 ;
14067 int res4 = SWIG_TMPOBJ ;
14068 unsigned char val5 ;
14069 int ecode5 = 0 ;
14070 unsigned char val6 ;
14071 int ecode6 = 0 ;
14072 unsigned char val7 ;
14073 int ecode7 = 0 ;
14074 PyObject * obj0 = 0 ;
14075 PyObject * obj1 = 0 ;
14076 PyObject * obj2 = 0 ;
14077 PyObject * obj3 = 0 ;
14078 char * kwnames[] = {
14079 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14080 };
14081
14082 arg2 = &temp2;
14083 arg3 = &temp3;
14084 arg4 = &temp4;
14085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14087 if (!SWIG_IsOK(res1)) {
14088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14089 }
14090 arg1 = reinterpret_cast< wxImage * >(argp1);
14091 if (obj1) {
14092 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14093 if (!SWIG_IsOK(ecode5)) {
14094 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14095 }
14096 arg5 = static_cast< byte >(val5);
14097 }
14098 if (obj2) {
14099 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14100 if (!SWIG_IsOK(ecode6)) {
14101 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14102 }
14103 arg6 = static_cast< byte >(val6);
14104 }
14105 if (obj3) {
14106 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14107 if (!SWIG_IsOK(ecode7)) {
14108 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14109 }
14110 arg7 = static_cast< byte >(val7);
14111 }
14112 {
14113 PyThreadState* __tstate = wxPyBeginAllowThreads();
14114 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14115 wxPyEndAllowThreads(__tstate);
14116 if (PyErr_Occurred()) SWIG_fail;
14117 }
14118 {
14119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14120 }
14121 if (SWIG_IsTmpObj(res2)) {
14122 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14123 } else {
14124 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14125 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14126 }
14127 if (SWIG_IsTmpObj(res3)) {
14128 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14129 } else {
14130 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14131 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14132 }
14133 if (SWIG_IsTmpObj(res4)) {
14134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14135 } else {
14136 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14137 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14138 }
14139 return resultobj;
14140 fail:
14141 return NULL;
14142 }
14143
14144
14145 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14146 PyObject *resultobj = 0;
14147 wxImage *arg1 = (wxImage *) 0 ;
14148 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14149 bool result;
14150 void *argp1 = 0 ;
14151 int res1 = 0 ;
14152 unsigned char val2 ;
14153 int ecode2 = 0 ;
14154 PyObject * obj0 = 0 ;
14155 PyObject * obj1 = 0 ;
14156 char * kwnames[] = {
14157 (char *) "self",(char *) "threshold", NULL
14158 };
14159
14160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14162 if (!SWIG_IsOK(res1)) {
14163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14164 }
14165 arg1 = reinterpret_cast< wxImage * >(argp1);
14166 if (obj1) {
14167 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14168 if (!SWIG_IsOK(ecode2)) {
14169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14170 }
14171 arg2 = static_cast< byte >(val2);
14172 }
14173 {
14174 PyThreadState* __tstate = wxPyBeginAllowThreads();
14175 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14176 wxPyEndAllowThreads(__tstate);
14177 if (PyErr_Occurred()) SWIG_fail;
14178 }
14179 {
14180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14181 }
14182 return resultobj;
14183 fail:
14184 return NULL;
14185 }
14186
14187
14188 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14189 PyObject *resultobj = 0;
14190 wxImage *arg1 = (wxImage *) 0 ;
14191 byte arg2 ;
14192 byte arg3 ;
14193 byte arg4 ;
14194 bool result;
14195 void *argp1 = 0 ;
14196 int res1 = 0 ;
14197 unsigned char val2 ;
14198 int ecode2 = 0 ;
14199 unsigned char val3 ;
14200 int ecode3 = 0 ;
14201 unsigned char val4 ;
14202 int ecode4 = 0 ;
14203 PyObject * obj0 = 0 ;
14204 PyObject * obj1 = 0 ;
14205 PyObject * obj2 = 0 ;
14206 PyObject * obj3 = 0 ;
14207 char * kwnames[] = {
14208 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14209 };
14210
14211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14213 if (!SWIG_IsOK(res1)) {
14214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14215 }
14216 arg1 = reinterpret_cast< wxImage * >(argp1);
14217 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14218 if (!SWIG_IsOK(ecode2)) {
14219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14220 }
14221 arg2 = static_cast< byte >(val2);
14222 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14223 if (!SWIG_IsOK(ecode3)) {
14224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14225 }
14226 arg3 = static_cast< byte >(val3);
14227 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14228 if (!SWIG_IsOK(ecode4)) {
14229 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14230 }
14231 arg4 = static_cast< byte >(val4);
14232 {
14233 PyThreadState* __tstate = wxPyBeginAllowThreads();
14234 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14235 wxPyEndAllowThreads(__tstate);
14236 if (PyErr_Occurred()) SWIG_fail;
14237 }
14238 {
14239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14240 }
14241 return resultobj;
14242 fail:
14243 return NULL;
14244 }
14245
14246
14247 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14248 PyObject *resultobj = 0;
14249 wxImage *arg1 = (wxImage *) 0 ;
14250 wxImage *arg2 = 0 ;
14251 byte arg3 ;
14252 byte arg4 ;
14253 byte arg5 ;
14254 bool result;
14255 void *argp1 = 0 ;
14256 int res1 = 0 ;
14257 void *argp2 = 0 ;
14258 int res2 = 0 ;
14259 unsigned char val3 ;
14260 int ecode3 = 0 ;
14261 unsigned char val4 ;
14262 int ecode4 = 0 ;
14263 unsigned char val5 ;
14264 int ecode5 = 0 ;
14265 PyObject * obj0 = 0 ;
14266 PyObject * obj1 = 0 ;
14267 PyObject * obj2 = 0 ;
14268 PyObject * obj3 = 0 ;
14269 PyObject * obj4 = 0 ;
14270 char * kwnames[] = {
14271 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14272 };
14273
14274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14276 if (!SWIG_IsOK(res1)) {
14277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14278 }
14279 arg1 = reinterpret_cast< wxImage * >(argp1);
14280 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14281 if (!SWIG_IsOK(res2)) {
14282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14283 }
14284 if (!argp2) {
14285 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14286 }
14287 arg2 = reinterpret_cast< wxImage * >(argp2);
14288 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14289 if (!SWIG_IsOK(ecode3)) {
14290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14291 }
14292 arg3 = static_cast< byte >(val3);
14293 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14294 if (!SWIG_IsOK(ecode4)) {
14295 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14296 }
14297 arg4 = static_cast< byte >(val4);
14298 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14299 if (!SWIG_IsOK(ecode5)) {
14300 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14301 }
14302 arg5 = static_cast< byte >(val5);
14303 {
14304 PyThreadState* __tstate = wxPyBeginAllowThreads();
14305 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14306 wxPyEndAllowThreads(__tstate);
14307 if (PyErr_Occurred()) SWIG_fail;
14308 }
14309 {
14310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14311 }
14312 return resultobj;
14313 fail:
14314 return NULL;
14315 }
14316
14317
14318 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14319 PyObject *resultobj = 0;
14320 wxString *arg1 = 0 ;
14321 bool result;
14322 bool temp1 = false ;
14323 PyObject * obj0 = 0 ;
14324 char * kwnames[] = {
14325 (char *) "filename", NULL
14326 };
14327
14328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14329 {
14330 arg1 = wxString_in_helper(obj0);
14331 if (arg1 == NULL) SWIG_fail;
14332 temp1 = true;
14333 }
14334 {
14335 PyThreadState* __tstate = wxPyBeginAllowThreads();
14336 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14337 wxPyEndAllowThreads(__tstate);
14338 if (PyErr_Occurred()) SWIG_fail;
14339 }
14340 {
14341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14342 }
14343 {
14344 if (temp1)
14345 delete arg1;
14346 }
14347 return resultobj;
14348 fail:
14349 {
14350 if (temp1)
14351 delete arg1;
14352 }
14353 return NULL;
14354 }
14355
14356
14357 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14358 PyObject *resultobj = 0;
14359 wxString *arg1 = 0 ;
14360 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14361 int result;
14362 bool temp1 = false ;
14363 long val2 ;
14364 int ecode2 = 0 ;
14365 PyObject * obj0 = 0 ;
14366 PyObject * obj1 = 0 ;
14367 char * kwnames[] = {
14368 (char *) "filename",(char *) "type", NULL
14369 };
14370
14371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14372 {
14373 arg1 = wxString_in_helper(obj0);
14374 if (arg1 == NULL) SWIG_fail;
14375 temp1 = true;
14376 }
14377 if (obj1) {
14378 ecode2 = SWIG_AsVal_long(obj1, &val2);
14379 if (!SWIG_IsOK(ecode2)) {
14380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14381 }
14382 arg2 = static_cast< long >(val2);
14383 }
14384 {
14385 PyThreadState* __tstate = wxPyBeginAllowThreads();
14386 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14387 wxPyEndAllowThreads(__tstate);
14388 if (PyErr_Occurred()) SWIG_fail;
14389 }
14390 resultobj = SWIG_From_int(static_cast< int >(result));
14391 {
14392 if (temp1)
14393 delete arg1;
14394 }
14395 return resultobj;
14396 fail:
14397 {
14398 if (temp1)
14399 delete arg1;
14400 }
14401 return NULL;
14402 }
14403
14404
14405 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14406 PyObject *resultobj = 0;
14407 wxImage *arg1 = (wxImage *) 0 ;
14408 wxString *arg2 = 0 ;
14409 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14410 int arg4 = (int) -1 ;
14411 bool result;
14412 void *argp1 = 0 ;
14413 int res1 = 0 ;
14414 bool temp2 = false ;
14415 long val3 ;
14416 int ecode3 = 0 ;
14417 int val4 ;
14418 int ecode4 = 0 ;
14419 PyObject * obj0 = 0 ;
14420 PyObject * obj1 = 0 ;
14421 PyObject * obj2 = 0 ;
14422 PyObject * obj3 = 0 ;
14423 char * kwnames[] = {
14424 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14425 };
14426
14427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14429 if (!SWIG_IsOK(res1)) {
14430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14431 }
14432 arg1 = reinterpret_cast< wxImage * >(argp1);
14433 {
14434 arg2 = wxString_in_helper(obj1);
14435 if (arg2 == NULL) SWIG_fail;
14436 temp2 = true;
14437 }
14438 if (obj2) {
14439 ecode3 = SWIG_AsVal_long(obj2, &val3);
14440 if (!SWIG_IsOK(ecode3)) {
14441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14442 }
14443 arg3 = static_cast< long >(val3);
14444 }
14445 if (obj3) {
14446 ecode4 = SWIG_AsVal_int(obj3, &val4);
14447 if (!SWIG_IsOK(ecode4)) {
14448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14449 }
14450 arg4 = static_cast< int >(val4);
14451 }
14452 {
14453 PyThreadState* __tstate = wxPyBeginAllowThreads();
14454 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14455 wxPyEndAllowThreads(__tstate);
14456 if (PyErr_Occurred()) SWIG_fail;
14457 }
14458 {
14459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14460 }
14461 {
14462 if (temp2)
14463 delete arg2;
14464 }
14465 return resultobj;
14466 fail:
14467 {
14468 if (temp2)
14469 delete arg2;
14470 }
14471 return NULL;
14472 }
14473
14474
14475 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14476 PyObject *resultobj = 0;
14477 wxImage *arg1 = (wxImage *) 0 ;
14478 wxString *arg2 = 0 ;
14479 wxString *arg3 = 0 ;
14480 int arg4 = (int) -1 ;
14481 bool result;
14482 void *argp1 = 0 ;
14483 int res1 = 0 ;
14484 bool temp2 = false ;
14485 bool temp3 = false ;
14486 int val4 ;
14487 int ecode4 = 0 ;
14488 PyObject * obj0 = 0 ;
14489 PyObject * obj1 = 0 ;
14490 PyObject * obj2 = 0 ;
14491 PyObject * obj3 = 0 ;
14492 char * kwnames[] = {
14493 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14494 };
14495
14496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14498 if (!SWIG_IsOK(res1)) {
14499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14500 }
14501 arg1 = reinterpret_cast< wxImage * >(argp1);
14502 {
14503 arg2 = wxString_in_helper(obj1);
14504 if (arg2 == NULL) SWIG_fail;
14505 temp2 = true;
14506 }
14507 {
14508 arg3 = wxString_in_helper(obj2);
14509 if (arg3 == NULL) SWIG_fail;
14510 temp3 = true;
14511 }
14512 if (obj3) {
14513 ecode4 = SWIG_AsVal_int(obj3, &val4);
14514 if (!SWIG_IsOK(ecode4)) {
14515 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14516 }
14517 arg4 = static_cast< int >(val4);
14518 }
14519 {
14520 PyThreadState* __tstate = wxPyBeginAllowThreads();
14521 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14522 wxPyEndAllowThreads(__tstate);
14523 if (PyErr_Occurred()) SWIG_fail;
14524 }
14525 {
14526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14527 }
14528 {
14529 if (temp2)
14530 delete arg2;
14531 }
14532 {
14533 if (temp3)
14534 delete arg3;
14535 }
14536 return resultobj;
14537 fail:
14538 {
14539 if (temp2)
14540 delete arg2;
14541 }
14542 {
14543 if (temp3)
14544 delete arg3;
14545 }
14546 return NULL;
14547 }
14548
14549
14550 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14551 PyObject *resultobj = 0;
14552 wxImage *arg1 = (wxImage *) 0 ;
14553 wxString *arg2 = 0 ;
14554 int arg3 ;
14555 bool result;
14556 void *argp1 = 0 ;
14557 int res1 = 0 ;
14558 bool temp2 = false ;
14559 int val3 ;
14560 int ecode3 = 0 ;
14561 PyObject * obj0 = 0 ;
14562 PyObject * obj1 = 0 ;
14563 PyObject * obj2 = 0 ;
14564 char * kwnames[] = {
14565 (char *) "self",(char *) "name",(char *) "type", NULL
14566 };
14567
14568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14570 if (!SWIG_IsOK(res1)) {
14571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14572 }
14573 arg1 = reinterpret_cast< wxImage * >(argp1);
14574 {
14575 arg2 = wxString_in_helper(obj1);
14576 if (arg2 == NULL) SWIG_fail;
14577 temp2 = true;
14578 }
14579 ecode3 = SWIG_AsVal_int(obj2, &val3);
14580 if (!SWIG_IsOK(ecode3)) {
14581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14582 }
14583 arg3 = static_cast< int >(val3);
14584 {
14585 PyThreadState* __tstate = wxPyBeginAllowThreads();
14586 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14587 wxPyEndAllowThreads(__tstate);
14588 if (PyErr_Occurred()) SWIG_fail;
14589 }
14590 {
14591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14592 }
14593 {
14594 if (temp2)
14595 delete arg2;
14596 }
14597 return resultobj;
14598 fail:
14599 {
14600 if (temp2)
14601 delete arg2;
14602 }
14603 return NULL;
14604 }
14605
14606
14607 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14608 PyObject *resultobj = 0;
14609 wxImage *arg1 = (wxImage *) 0 ;
14610 wxString *arg2 = 0 ;
14611 wxString *arg3 = 0 ;
14612 bool result;
14613 void *argp1 = 0 ;
14614 int res1 = 0 ;
14615 bool temp2 = false ;
14616 bool temp3 = false ;
14617 PyObject * obj0 = 0 ;
14618 PyObject * obj1 = 0 ;
14619 PyObject * obj2 = 0 ;
14620 char * kwnames[] = {
14621 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14622 };
14623
14624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14626 if (!SWIG_IsOK(res1)) {
14627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14628 }
14629 arg1 = reinterpret_cast< wxImage * >(argp1);
14630 {
14631 arg2 = wxString_in_helper(obj1);
14632 if (arg2 == NULL) SWIG_fail;
14633 temp2 = true;
14634 }
14635 {
14636 arg3 = wxString_in_helper(obj2);
14637 if (arg3 == NULL) SWIG_fail;
14638 temp3 = true;
14639 }
14640 {
14641 PyThreadState* __tstate = wxPyBeginAllowThreads();
14642 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14643 wxPyEndAllowThreads(__tstate);
14644 if (PyErr_Occurred()) SWIG_fail;
14645 }
14646 {
14647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14648 }
14649 {
14650 if (temp2)
14651 delete arg2;
14652 }
14653 {
14654 if (temp3)
14655 delete arg3;
14656 }
14657 return resultobj;
14658 fail:
14659 {
14660 if (temp2)
14661 delete arg2;
14662 }
14663 {
14664 if (temp3)
14665 delete arg3;
14666 }
14667 return NULL;
14668 }
14669
14670
14671 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14672 PyObject *resultobj = 0;
14673 wxInputStream *arg1 = 0 ;
14674 bool result;
14675 wxPyInputStream *temp1 ;
14676 bool created1 ;
14677 PyObject * obj0 = 0 ;
14678 char * kwnames[] = {
14679 (char *) "stream", NULL
14680 };
14681
14682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14683 {
14684 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14685 arg1 = temp1->m_wxis;
14686 created1 = false;
14687 } else {
14688 PyErr_Clear(); // clear the failure of the wxPyConvert above
14689 arg1 = wxPyCBInputStream_create(obj0, false);
14690 if (arg1 == NULL) {
14691 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14692 SWIG_fail;
14693 }
14694 created1 = true;
14695 }
14696 }
14697 {
14698 PyThreadState* __tstate = wxPyBeginAllowThreads();
14699 result = (bool)wxImage::CanRead(*arg1);
14700 wxPyEndAllowThreads(__tstate);
14701 if (PyErr_Occurred()) SWIG_fail;
14702 }
14703 {
14704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14705 }
14706 {
14707 if (created1) delete arg1;
14708 }
14709 return resultobj;
14710 fail:
14711 {
14712 if (created1) delete arg1;
14713 }
14714 return NULL;
14715 }
14716
14717
14718 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14719 PyObject *resultobj = 0;
14720 wxImage *arg1 = (wxImage *) 0 ;
14721 wxInputStream *arg2 = 0 ;
14722 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14723 int arg4 = (int) -1 ;
14724 bool result;
14725 void *argp1 = 0 ;
14726 int res1 = 0 ;
14727 wxPyInputStream *temp2 ;
14728 bool created2 ;
14729 long val3 ;
14730 int ecode3 = 0 ;
14731 int val4 ;
14732 int ecode4 = 0 ;
14733 PyObject * obj0 = 0 ;
14734 PyObject * obj1 = 0 ;
14735 PyObject * obj2 = 0 ;
14736 PyObject * obj3 = 0 ;
14737 char * kwnames[] = {
14738 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14739 };
14740
14741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14743 if (!SWIG_IsOK(res1)) {
14744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14745 }
14746 arg1 = reinterpret_cast< wxImage * >(argp1);
14747 {
14748 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14749 arg2 = temp2->m_wxis;
14750 created2 = false;
14751 } else {
14752 PyErr_Clear(); // clear the failure of the wxPyConvert above
14753 arg2 = wxPyCBInputStream_create(obj1, false);
14754 if (arg2 == NULL) {
14755 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14756 SWIG_fail;
14757 }
14758 created2 = true;
14759 }
14760 }
14761 if (obj2) {
14762 ecode3 = SWIG_AsVal_long(obj2, &val3);
14763 if (!SWIG_IsOK(ecode3)) {
14764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14765 }
14766 arg3 = static_cast< long >(val3);
14767 }
14768 if (obj3) {
14769 ecode4 = SWIG_AsVal_int(obj3, &val4);
14770 if (!SWIG_IsOK(ecode4)) {
14771 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14772 }
14773 arg4 = static_cast< int >(val4);
14774 }
14775 {
14776 PyThreadState* __tstate = wxPyBeginAllowThreads();
14777 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14778 wxPyEndAllowThreads(__tstate);
14779 if (PyErr_Occurred()) SWIG_fail;
14780 }
14781 {
14782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14783 }
14784 {
14785 if (created2) delete arg2;
14786 }
14787 return resultobj;
14788 fail:
14789 {
14790 if (created2) delete arg2;
14791 }
14792 return NULL;
14793 }
14794
14795
14796 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14797 PyObject *resultobj = 0;
14798 wxImage *arg1 = (wxImage *) 0 ;
14799 wxInputStream *arg2 = 0 ;
14800 wxString *arg3 = 0 ;
14801 int arg4 = (int) -1 ;
14802 bool result;
14803 void *argp1 = 0 ;
14804 int res1 = 0 ;
14805 wxPyInputStream *temp2 ;
14806 bool created2 ;
14807 bool temp3 = false ;
14808 int val4 ;
14809 int ecode4 = 0 ;
14810 PyObject * obj0 = 0 ;
14811 PyObject * obj1 = 0 ;
14812 PyObject * obj2 = 0 ;
14813 PyObject * obj3 = 0 ;
14814 char * kwnames[] = {
14815 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14816 };
14817
14818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14820 if (!SWIG_IsOK(res1)) {
14821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14822 }
14823 arg1 = reinterpret_cast< wxImage * >(argp1);
14824 {
14825 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14826 arg2 = temp2->m_wxis;
14827 created2 = false;
14828 } else {
14829 PyErr_Clear(); // clear the failure of the wxPyConvert above
14830 arg2 = wxPyCBInputStream_create(obj1, false);
14831 if (arg2 == NULL) {
14832 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14833 SWIG_fail;
14834 }
14835 created2 = true;
14836 }
14837 }
14838 {
14839 arg3 = wxString_in_helper(obj2);
14840 if (arg3 == NULL) SWIG_fail;
14841 temp3 = true;
14842 }
14843 if (obj3) {
14844 ecode4 = SWIG_AsVal_int(obj3, &val4);
14845 if (!SWIG_IsOK(ecode4)) {
14846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14847 }
14848 arg4 = static_cast< int >(val4);
14849 }
14850 {
14851 PyThreadState* __tstate = wxPyBeginAllowThreads();
14852 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14853 wxPyEndAllowThreads(__tstate);
14854 if (PyErr_Occurred()) SWIG_fail;
14855 }
14856 {
14857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14858 }
14859 {
14860 if (created2) delete arg2;
14861 }
14862 {
14863 if (temp3)
14864 delete arg3;
14865 }
14866 return resultobj;
14867 fail:
14868 {
14869 if (created2) delete arg2;
14870 }
14871 {
14872 if (temp3)
14873 delete arg3;
14874 }
14875 return NULL;
14876 }
14877
14878
14879 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14880 PyObject *resultobj = 0;
14881 wxImage *arg1 = (wxImage *) 0 ;
14882 bool result;
14883 void *argp1 = 0 ;
14884 int res1 = 0 ;
14885 PyObject *swig_obj[1] ;
14886
14887 if (!args) SWIG_fail;
14888 swig_obj[0] = args;
14889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14890 if (!SWIG_IsOK(res1)) {
14891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14892 }
14893 arg1 = reinterpret_cast< wxImage * >(argp1);
14894 {
14895 PyThreadState* __tstate = wxPyBeginAllowThreads();
14896 result = (bool)(arg1)->Ok();
14897 wxPyEndAllowThreads(__tstate);
14898 if (PyErr_Occurred()) SWIG_fail;
14899 }
14900 {
14901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14902 }
14903 return resultobj;
14904 fail:
14905 return NULL;
14906 }
14907
14908
14909 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14910 PyObject *resultobj = 0;
14911 wxImage *arg1 = (wxImage *) 0 ;
14912 int result;
14913 void *argp1 = 0 ;
14914 int res1 = 0 ;
14915 PyObject *swig_obj[1] ;
14916
14917 if (!args) SWIG_fail;
14918 swig_obj[0] = args;
14919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14920 if (!SWIG_IsOK(res1)) {
14921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
14922 }
14923 arg1 = reinterpret_cast< wxImage * >(argp1);
14924 {
14925 PyThreadState* __tstate = wxPyBeginAllowThreads();
14926 result = (int)(arg1)->GetWidth();
14927 wxPyEndAllowThreads(__tstate);
14928 if (PyErr_Occurred()) SWIG_fail;
14929 }
14930 resultobj = SWIG_From_int(static_cast< int >(result));
14931 return resultobj;
14932 fail:
14933 return NULL;
14934 }
14935
14936
14937 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14938 PyObject *resultobj = 0;
14939 wxImage *arg1 = (wxImage *) 0 ;
14940 int result;
14941 void *argp1 = 0 ;
14942 int res1 = 0 ;
14943 PyObject *swig_obj[1] ;
14944
14945 if (!args) SWIG_fail;
14946 swig_obj[0] = args;
14947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14948 if (!SWIG_IsOK(res1)) {
14949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
14950 }
14951 arg1 = reinterpret_cast< wxImage * >(argp1);
14952 {
14953 PyThreadState* __tstate = wxPyBeginAllowThreads();
14954 result = (int)(arg1)->GetHeight();
14955 wxPyEndAllowThreads(__tstate);
14956 if (PyErr_Occurred()) SWIG_fail;
14957 }
14958 resultobj = SWIG_From_int(static_cast< int >(result));
14959 return resultobj;
14960 fail:
14961 return NULL;
14962 }
14963
14964
14965 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14966 PyObject *resultobj = 0;
14967 wxImage *arg1 = (wxImage *) 0 ;
14968 wxSize result;
14969 void *argp1 = 0 ;
14970 int res1 = 0 ;
14971 PyObject *swig_obj[1] ;
14972
14973 if (!args) SWIG_fail;
14974 swig_obj[0] = args;
14975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14976 if (!SWIG_IsOK(res1)) {
14977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
14978 }
14979 arg1 = reinterpret_cast< wxImage * >(argp1);
14980 {
14981 PyThreadState* __tstate = wxPyBeginAllowThreads();
14982 result = wxImage_GetSize(arg1);
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
14987 return resultobj;
14988 fail:
14989 return NULL;
14990 }
14991
14992
14993 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14994 PyObject *resultobj = 0;
14995 wxImage *arg1 = (wxImage *) 0 ;
14996 wxRect *arg2 = 0 ;
14997 SwigValueWrapper<wxImage > result;
14998 void *argp1 = 0 ;
14999 int res1 = 0 ;
15000 wxRect temp2 ;
15001 PyObject * obj0 = 0 ;
15002 PyObject * obj1 = 0 ;
15003 char * kwnames[] = {
15004 (char *) "self",(char *) "rect", NULL
15005 };
15006
15007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15009 if (!SWIG_IsOK(res1)) {
15010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15011 }
15012 arg1 = reinterpret_cast< wxImage * >(argp1);
15013 {
15014 arg2 = &temp2;
15015 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15016 }
15017 {
15018 PyThreadState* __tstate = wxPyBeginAllowThreads();
15019 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15020 wxPyEndAllowThreads(__tstate);
15021 if (PyErr_Occurred()) SWIG_fail;
15022 }
15023 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15024 return resultobj;
15025 fail:
15026 return NULL;
15027 }
15028
15029
15030 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15031 PyObject *resultobj = 0;
15032 wxImage *arg1 = (wxImage *) 0 ;
15033 wxSize *arg2 = 0 ;
15034 wxPoint *arg3 = 0 ;
15035 int arg4 = (int) -1 ;
15036 int arg5 = (int) -1 ;
15037 int arg6 = (int) -1 ;
15038 SwigValueWrapper<wxImage > result;
15039 void *argp1 = 0 ;
15040 int res1 = 0 ;
15041 wxSize temp2 ;
15042 wxPoint temp3 ;
15043 int val4 ;
15044 int ecode4 = 0 ;
15045 int val5 ;
15046 int ecode5 = 0 ;
15047 int val6 ;
15048 int ecode6 = 0 ;
15049 PyObject * obj0 = 0 ;
15050 PyObject * obj1 = 0 ;
15051 PyObject * obj2 = 0 ;
15052 PyObject * obj3 = 0 ;
15053 PyObject * obj4 = 0 ;
15054 PyObject * obj5 = 0 ;
15055 char * kwnames[] = {
15056 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15057 };
15058
15059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15061 if (!SWIG_IsOK(res1)) {
15062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15063 }
15064 arg1 = reinterpret_cast< wxImage * >(argp1);
15065 {
15066 arg2 = &temp2;
15067 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15068 }
15069 {
15070 arg3 = &temp3;
15071 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15072 }
15073 if (obj3) {
15074 ecode4 = SWIG_AsVal_int(obj3, &val4);
15075 if (!SWIG_IsOK(ecode4)) {
15076 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15077 }
15078 arg4 = static_cast< int >(val4);
15079 }
15080 if (obj4) {
15081 ecode5 = SWIG_AsVal_int(obj4, &val5);
15082 if (!SWIG_IsOK(ecode5)) {
15083 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15084 }
15085 arg5 = static_cast< int >(val5);
15086 }
15087 if (obj5) {
15088 ecode6 = SWIG_AsVal_int(obj5, &val6);
15089 if (!SWIG_IsOK(ecode6)) {
15090 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15091 }
15092 arg6 = static_cast< int >(val6);
15093 }
15094 {
15095 PyThreadState* __tstate = wxPyBeginAllowThreads();
15096 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15097 wxPyEndAllowThreads(__tstate);
15098 if (PyErr_Occurred()) SWIG_fail;
15099 }
15100 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15101 return resultobj;
15102 fail:
15103 return NULL;
15104 }
15105
15106
15107 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15108 PyObject *resultobj = 0;
15109 wxImage *arg1 = (wxImage *) 0 ;
15110 SwigValueWrapper<wxImage > result;
15111 void *argp1 = 0 ;
15112 int res1 = 0 ;
15113 PyObject *swig_obj[1] ;
15114
15115 if (!args) SWIG_fail;
15116 swig_obj[0] = args;
15117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15118 if (!SWIG_IsOK(res1)) {
15119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15120 }
15121 arg1 = reinterpret_cast< wxImage * >(argp1);
15122 {
15123 PyThreadState* __tstate = wxPyBeginAllowThreads();
15124 result = (arg1)->Copy();
15125 wxPyEndAllowThreads(__tstate);
15126 if (PyErr_Occurred()) SWIG_fail;
15127 }
15128 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15129 return resultobj;
15130 fail:
15131 return NULL;
15132 }
15133
15134
15135 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15136 PyObject *resultobj = 0;
15137 wxImage *arg1 = (wxImage *) 0 ;
15138 wxImage *arg2 = 0 ;
15139 int arg3 ;
15140 int arg4 ;
15141 void *argp1 = 0 ;
15142 int res1 = 0 ;
15143 void *argp2 = 0 ;
15144 int res2 = 0 ;
15145 int val3 ;
15146 int ecode3 = 0 ;
15147 int val4 ;
15148 int ecode4 = 0 ;
15149 PyObject * obj0 = 0 ;
15150 PyObject * obj1 = 0 ;
15151 PyObject * obj2 = 0 ;
15152 PyObject * obj3 = 0 ;
15153 char * kwnames[] = {
15154 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15155 };
15156
15157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15159 if (!SWIG_IsOK(res1)) {
15160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15161 }
15162 arg1 = reinterpret_cast< wxImage * >(argp1);
15163 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15164 if (!SWIG_IsOK(res2)) {
15165 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15166 }
15167 if (!argp2) {
15168 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15169 }
15170 arg2 = reinterpret_cast< wxImage * >(argp2);
15171 ecode3 = SWIG_AsVal_int(obj2, &val3);
15172 if (!SWIG_IsOK(ecode3)) {
15173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15174 }
15175 arg3 = static_cast< int >(val3);
15176 ecode4 = SWIG_AsVal_int(obj3, &val4);
15177 if (!SWIG_IsOK(ecode4)) {
15178 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15179 }
15180 arg4 = static_cast< int >(val4);
15181 {
15182 PyThreadState* __tstate = wxPyBeginAllowThreads();
15183 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15184 wxPyEndAllowThreads(__tstate);
15185 if (PyErr_Occurred()) SWIG_fail;
15186 }
15187 resultobj = SWIG_Py_Void();
15188 return resultobj;
15189 fail:
15190 return NULL;
15191 }
15192
15193
15194 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15195 PyObject *resultobj = 0;
15196 wxImage *arg1 = (wxImage *) 0 ;
15197 PyObject *result = 0 ;
15198 void *argp1 = 0 ;
15199 int res1 = 0 ;
15200 PyObject *swig_obj[1] ;
15201
15202 if (!args) SWIG_fail;
15203 swig_obj[0] = args;
15204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15205 if (!SWIG_IsOK(res1)) {
15206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15207 }
15208 arg1 = reinterpret_cast< wxImage * >(argp1);
15209 {
15210 PyThreadState* __tstate = wxPyBeginAllowThreads();
15211 result = (PyObject *)wxImage_GetData(arg1);
15212 wxPyEndAllowThreads(__tstate);
15213 if (PyErr_Occurred()) SWIG_fail;
15214 }
15215 resultobj = result;
15216 return resultobj;
15217 fail:
15218 return NULL;
15219 }
15220
15221
15222 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15223 PyObject *resultobj = 0;
15224 wxImage *arg1 = (wxImage *) 0 ;
15225 buffer arg2 ;
15226 int arg3 ;
15227 void *argp1 = 0 ;
15228 int res1 = 0 ;
15229 PyObject * obj0 = 0 ;
15230 PyObject * obj1 = 0 ;
15231 char * kwnames[] = {
15232 (char *) "self",(char *) "data", NULL
15233 };
15234
15235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15237 if (!SWIG_IsOK(res1)) {
15238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15239 }
15240 arg1 = reinterpret_cast< wxImage * >(argp1);
15241 {
15242 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15243 }
15244 {
15245 PyThreadState* __tstate = wxPyBeginAllowThreads();
15246 wxImage_SetData(arg1,arg2,arg3);
15247 wxPyEndAllowThreads(__tstate);
15248 if (PyErr_Occurred()) SWIG_fail;
15249 }
15250 resultobj = SWIG_Py_Void();
15251 return resultobj;
15252 fail:
15253 return NULL;
15254 }
15255
15256
15257 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15258 PyObject *resultobj = 0;
15259 wxImage *arg1 = (wxImage *) 0 ;
15260 PyObject *result = 0 ;
15261 void *argp1 = 0 ;
15262 int res1 = 0 ;
15263 PyObject *swig_obj[1] ;
15264
15265 if (!args) SWIG_fail;
15266 swig_obj[0] = args;
15267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15268 if (!SWIG_IsOK(res1)) {
15269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15270 }
15271 arg1 = reinterpret_cast< wxImage * >(argp1);
15272 {
15273 PyThreadState* __tstate = wxPyBeginAllowThreads();
15274 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15275 wxPyEndAllowThreads(__tstate);
15276 if (PyErr_Occurred()) SWIG_fail;
15277 }
15278 resultobj = result;
15279 return resultobj;
15280 fail:
15281 return NULL;
15282 }
15283
15284
15285 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15286 PyObject *resultobj = 0;
15287 wxImage *arg1 = (wxImage *) 0 ;
15288 buffer arg2 ;
15289 int arg3 ;
15290 void *argp1 = 0 ;
15291 int res1 = 0 ;
15292 PyObject * obj0 = 0 ;
15293 PyObject * obj1 = 0 ;
15294 char * kwnames[] = {
15295 (char *) "self",(char *) "data", NULL
15296 };
15297
15298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15300 if (!SWIG_IsOK(res1)) {
15301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15302 }
15303 arg1 = reinterpret_cast< wxImage * >(argp1);
15304 {
15305 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15306 }
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 wxImage_SetDataBuffer(arg1,arg2,arg3);
15310 wxPyEndAllowThreads(__tstate);
15311 if (PyErr_Occurred()) SWIG_fail;
15312 }
15313 resultobj = SWIG_Py_Void();
15314 return resultobj;
15315 fail:
15316 return NULL;
15317 }
15318
15319
15320 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15321 PyObject *resultobj = 0;
15322 wxImage *arg1 = (wxImage *) 0 ;
15323 PyObject *result = 0 ;
15324 void *argp1 = 0 ;
15325 int res1 = 0 ;
15326 PyObject *swig_obj[1] ;
15327
15328 if (!args) SWIG_fail;
15329 swig_obj[0] = args;
15330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15331 if (!SWIG_IsOK(res1)) {
15332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15333 }
15334 arg1 = reinterpret_cast< wxImage * >(argp1);
15335 {
15336 PyThreadState* __tstate = wxPyBeginAllowThreads();
15337 result = (PyObject *)wxImage_GetAlphaData(arg1);
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 resultobj = result;
15342 return resultobj;
15343 fail:
15344 return NULL;
15345 }
15346
15347
15348 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15349 PyObject *resultobj = 0;
15350 wxImage *arg1 = (wxImage *) 0 ;
15351 buffer arg2 ;
15352 int arg3 ;
15353 void *argp1 = 0 ;
15354 int res1 = 0 ;
15355 PyObject * obj0 = 0 ;
15356 PyObject * obj1 = 0 ;
15357 char * kwnames[] = {
15358 (char *) "self",(char *) "alpha", NULL
15359 };
15360
15361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15363 if (!SWIG_IsOK(res1)) {
15364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15365 }
15366 arg1 = reinterpret_cast< wxImage * >(argp1);
15367 {
15368 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15369 }
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 wxImage_SetAlphaData(arg1,arg2,arg3);
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 resultobj = SWIG_Py_Void();
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15384 PyObject *resultobj = 0;
15385 wxImage *arg1 = (wxImage *) 0 ;
15386 PyObject *result = 0 ;
15387 void *argp1 = 0 ;
15388 int res1 = 0 ;
15389 PyObject *swig_obj[1] ;
15390
15391 if (!args) SWIG_fail;
15392 swig_obj[0] = args;
15393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15396 }
15397 arg1 = reinterpret_cast< wxImage * >(argp1);
15398 {
15399 PyThreadState* __tstate = wxPyBeginAllowThreads();
15400 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 resultobj = result;
15405 return resultobj;
15406 fail:
15407 return NULL;
15408 }
15409
15410
15411 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15412 PyObject *resultobj = 0;
15413 wxImage *arg1 = (wxImage *) 0 ;
15414 buffer arg2 ;
15415 int arg3 ;
15416 void *argp1 = 0 ;
15417 int res1 = 0 ;
15418 PyObject * obj0 = 0 ;
15419 PyObject * obj1 = 0 ;
15420 char * kwnames[] = {
15421 (char *) "self",(char *) "alpha", NULL
15422 };
15423
15424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15426 if (!SWIG_IsOK(res1)) {
15427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15428 }
15429 arg1 = reinterpret_cast< wxImage * >(argp1);
15430 {
15431 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15432 }
15433 {
15434 PyThreadState* __tstate = wxPyBeginAllowThreads();
15435 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15436 wxPyEndAllowThreads(__tstate);
15437 if (PyErr_Occurred()) SWIG_fail;
15438 }
15439 resultobj = SWIG_Py_Void();
15440 return resultobj;
15441 fail:
15442 return NULL;
15443 }
15444
15445
15446 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15447 PyObject *resultobj = 0;
15448 wxImage *arg1 = (wxImage *) 0 ;
15449 byte arg2 ;
15450 byte arg3 ;
15451 byte arg4 ;
15452 void *argp1 = 0 ;
15453 int res1 = 0 ;
15454 unsigned char val2 ;
15455 int ecode2 = 0 ;
15456 unsigned char val3 ;
15457 int ecode3 = 0 ;
15458 unsigned char val4 ;
15459 int ecode4 = 0 ;
15460 PyObject * obj0 = 0 ;
15461 PyObject * obj1 = 0 ;
15462 PyObject * obj2 = 0 ;
15463 PyObject * obj3 = 0 ;
15464 char * kwnames[] = {
15465 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15466 };
15467
15468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15470 if (!SWIG_IsOK(res1)) {
15471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15472 }
15473 arg1 = reinterpret_cast< wxImage * >(argp1);
15474 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15475 if (!SWIG_IsOK(ecode2)) {
15476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15477 }
15478 arg2 = static_cast< byte >(val2);
15479 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15480 if (!SWIG_IsOK(ecode3)) {
15481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15482 }
15483 arg3 = static_cast< byte >(val3);
15484 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15485 if (!SWIG_IsOK(ecode4)) {
15486 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15487 }
15488 arg4 = static_cast< byte >(val4);
15489 {
15490 PyThreadState* __tstate = wxPyBeginAllowThreads();
15491 (arg1)->SetMaskColour(arg2,arg3,arg4);
15492 wxPyEndAllowThreads(__tstate);
15493 if (PyErr_Occurred()) SWIG_fail;
15494 }
15495 resultobj = SWIG_Py_Void();
15496 return resultobj;
15497 fail:
15498 return NULL;
15499 }
15500
15501
15502 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15503 PyObject *resultobj = 0;
15504 wxImage *arg1 = (wxImage *) 0 ;
15505 byte *arg2 = (byte *) 0 ;
15506 byte *arg3 = (byte *) 0 ;
15507 byte *arg4 = (byte *) 0 ;
15508 void *argp1 = 0 ;
15509 int res1 = 0 ;
15510 byte temp2 ;
15511 int res2 = SWIG_TMPOBJ ;
15512 byte temp3 ;
15513 int res3 = SWIG_TMPOBJ ;
15514 byte temp4 ;
15515 int res4 = SWIG_TMPOBJ ;
15516 PyObject *swig_obj[1] ;
15517
15518 arg2 = &temp2;
15519 arg3 = &temp3;
15520 arg4 = &temp4;
15521 if (!args) SWIG_fail;
15522 swig_obj[0] = args;
15523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15524 if (!SWIG_IsOK(res1)) {
15525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15526 }
15527 arg1 = reinterpret_cast< wxImage * >(argp1);
15528 {
15529 PyThreadState* __tstate = wxPyBeginAllowThreads();
15530 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15531 wxPyEndAllowThreads(__tstate);
15532 if (PyErr_Occurred()) SWIG_fail;
15533 }
15534 resultobj = SWIG_Py_Void();
15535 if (SWIG_IsTmpObj(res2)) {
15536 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15537 } else {
15538 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15539 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15540 }
15541 if (SWIG_IsTmpObj(res3)) {
15542 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15543 } else {
15544 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15545 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15546 }
15547 if (SWIG_IsTmpObj(res4)) {
15548 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15549 } else {
15550 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15551 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15552 }
15553 return resultobj;
15554 fail:
15555 return NULL;
15556 }
15557
15558
15559 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15560 PyObject *resultobj = 0;
15561 wxImage *arg1 = (wxImage *) 0 ;
15562 byte result;
15563 void *argp1 = 0 ;
15564 int res1 = 0 ;
15565 PyObject *swig_obj[1] ;
15566
15567 if (!args) SWIG_fail;
15568 swig_obj[0] = args;
15569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15570 if (!SWIG_IsOK(res1)) {
15571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15572 }
15573 arg1 = reinterpret_cast< wxImage * >(argp1);
15574 {
15575 PyThreadState* __tstate = wxPyBeginAllowThreads();
15576 result = (byte)(arg1)->GetMaskRed();
15577 wxPyEndAllowThreads(__tstate);
15578 if (PyErr_Occurred()) SWIG_fail;
15579 }
15580 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15581 return resultobj;
15582 fail:
15583 return NULL;
15584 }
15585
15586
15587 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15588 PyObject *resultobj = 0;
15589 wxImage *arg1 = (wxImage *) 0 ;
15590 byte result;
15591 void *argp1 = 0 ;
15592 int res1 = 0 ;
15593 PyObject *swig_obj[1] ;
15594
15595 if (!args) SWIG_fail;
15596 swig_obj[0] = args;
15597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15598 if (!SWIG_IsOK(res1)) {
15599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15600 }
15601 arg1 = reinterpret_cast< wxImage * >(argp1);
15602 {
15603 PyThreadState* __tstate = wxPyBeginAllowThreads();
15604 result = (byte)(arg1)->GetMaskGreen();
15605 wxPyEndAllowThreads(__tstate);
15606 if (PyErr_Occurred()) SWIG_fail;
15607 }
15608 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15609 return resultobj;
15610 fail:
15611 return NULL;
15612 }
15613
15614
15615 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15616 PyObject *resultobj = 0;
15617 wxImage *arg1 = (wxImage *) 0 ;
15618 byte result;
15619 void *argp1 = 0 ;
15620 int res1 = 0 ;
15621 PyObject *swig_obj[1] ;
15622
15623 if (!args) SWIG_fail;
15624 swig_obj[0] = args;
15625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15626 if (!SWIG_IsOK(res1)) {
15627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15628 }
15629 arg1 = reinterpret_cast< wxImage * >(argp1);
15630 {
15631 PyThreadState* __tstate = wxPyBeginAllowThreads();
15632 result = (byte)(arg1)->GetMaskBlue();
15633 wxPyEndAllowThreads(__tstate);
15634 if (PyErr_Occurred()) SWIG_fail;
15635 }
15636 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15637 return resultobj;
15638 fail:
15639 return NULL;
15640 }
15641
15642
15643 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15644 PyObject *resultobj = 0;
15645 wxImage *arg1 = (wxImage *) 0 ;
15646 bool arg2 = (bool) true ;
15647 void *argp1 = 0 ;
15648 int res1 = 0 ;
15649 bool val2 ;
15650 int ecode2 = 0 ;
15651 PyObject * obj0 = 0 ;
15652 PyObject * obj1 = 0 ;
15653 char * kwnames[] = {
15654 (char *) "self",(char *) "mask", NULL
15655 };
15656
15657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15659 if (!SWIG_IsOK(res1)) {
15660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15661 }
15662 arg1 = reinterpret_cast< wxImage * >(argp1);
15663 if (obj1) {
15664 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15665 if (!SWIG_IsOK(ecode2)) {
15666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15667 }
15668 arg2 = static_cast< bool >(val2);
15669 }
15670 {
15671 PyThreadState* __tstate = wxPyBeginAllowThreads();
15672 (arg1)->SetMask(arg2);
15673 wxPyEndAllowThreads(__tstate);
15674 if (PyErr_Occurred()) SWIG_fail;
15675 }
15676 resultobj = SWIG_Py_Void();
15677 return resultobj;
15678 fail:
15679 return NULL;
15680 }
15681
15682
15683 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15684 PyObject *resultobj = 0;
15685 wxImage *arg1 = (wxImage *) 0 ;
15686 bool result;
15687 void *argp1 = 0 ;
15688 int res1 = 0 ;
15689 PyObject *swig_obj[1] ;
15690
15691 if (!args) SWIG_fail;
15692 swig_obj[0] = args;
15693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15694 if (!SWIG_IsOK(res1)) {
15695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15696 }
15697 arg1 = reinterpret_cast< wxImage * >(argp1);
15698 {
15699 PyThreadState* __tstate = wxPyBeginAllowThreads();
15700 result = (bool)(arg1)->HasMask();
15701 wxPyEndAllowThreads(__tstate);
15702 if (PyErr_Occurred()) SWIG_fail;
15703 }
15704 {
15705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15706 }
15707 return resultobj;
15708 fail:
15709 return NULL;
15710 }
15711
15712
15713 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15714 PyObject *resultobj = 0;
15715 wxImage *arg1 = (wxImage *) 0 ;
15716 double arg2 ;
15717 wxPoint *arg3 = 0 ;
15718 bool arg4 = (bool) true ;
15719 wxPoint *arg5 = (wxPoint *) NULL ;
15720 SwigValueWrapper<wxImage > result;
15721 void *argp1 = 0 ;
15722 int res1 = 0 ;
15723 double val2 ;
15724 int ecode2 = 0 ;
15725 wxPoint temp3 ;
15726 bool val4 ;
15727 int ecode4 = 0 ;
15728 void *argp5 = 0 ;
15729 int res5 = 0 ;
15730 PyObject * obj0 = 0 ;
15731 PyObject * obj1 = 0 ;
15732 PyObject * obj2 = 0 ;
15733 PyObject * obj3 = 0 ;
15734 PyObject * obj4 = 0 ;
15735 char * kwnames[] = {
15736 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15737 };
15738
15739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15741 if (!SWIG_IsOK(res1)) {
15742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15743 }
15744 arg1 = reinterpret_cast< wxImage * >(argp1);
15745 ecode2 = SWIG_AsVal_double(obj1, &val2);
15746 if (!SWIG_IsOK(ecode2)) {
15747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15748 }
15749 arg2 = static_cast< double >(val2);
15750 {
15751 arg3 = &temp3;
15752 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15753 }
15754 if (obj3) {
15755 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15756 if (!SWIG_IsOK(ecode4)) {
15757 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15758 }
15759 arg4 = static_cast< bool >(val4);
15760 }
15761 if (obj4) {
15762 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15763 if (!SWIG_IsOK(res5)) {
15764 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15765 }
15766 arg5 = reinterpret_cast< wxPoint * >(argp5);
15767 }
15768 {
15769 PyThreadState* __tstate = wxPyBeginAllowThreads();
15770 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15771 wxPyEndAllowThreads(__tstate);
15772 if (PyErr_Occurred()) SWIG_fail;
15773 }
15774 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15775 return resultobj;
15776 fail:
15777 return NULL;
15778 }
15779
15780
15781 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15782 PyObject *resultobj = 0;
15783 wxImage *arg1 = (wxImage *) 0 ;
15784 bool arg2 = (bool) true ;
15785 SwigValueWrapper<wxImage > result;
15786 void *argp1 = 0 ;
15787 int res1 = 0 ;
15788 bool val2 ;
15789 int ecode2 = 0 ;
15790 PyObject * obj0 = 0 ;
15791 PyObject * obj1 = 0 ;
15792 char * kwnames[] = {
15793 (char *) "self",(char *) "clockwise", NULL
15794 };
15795
15796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15798 if (!SWIG_IsOK(res1)) {
15799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15800 }
15801 arg1 = reinterpret_cast< wxImage * >(argp1);
15802 if (obj1) {
15803 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15804 if (!SWIG_IsOK(ecode2)) {
15805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15806 }
15807 arg2 = static_cast< bool >(val2);
15808 }
15809 {
15810 PyThreadState* __tstate = wxPyBeginAllowThreads();
15811 result = (arg1)->Rotate90(arg2);
15812 wxPyEndAllowThreads(__tstate);
15813 if (PyErr_Occurred()) SWIG_fail;
15814 }
15815 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15816 return resultobj;
15817 fail:
15818 return NULL;
15819 }
15820
15821
15822 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15823 PyObject *resultobj = 0;
15824 wxImage *arg1 = (wxImage *) 0 ;
15825 bool arg2 = (bool) true ;
15826 SwigValueWrapper<wxImage > result;
15827 void *argp1 = 0 ;
15828 int res1 = 0 ;
15829 bool val2 ;
15830 int ecode2 = 0 ;
15831 PyObject * obj0 = 0 ;
15832 PyObject * obj1 = 0 ;
15833 char * kwnames[] = {
15834 (char *) "self",(char *) "horizontally", NULL
15835 };
15836
15837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15839 if (!SWIG_IsOK(res1)) {
15840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15841 }
15842 arg1 = reinterpret_cast< wxImage * >(argp1);
15843 if (obj1) {
15844 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15845 if (!SWIG_IsOK(ecode2)) {
15846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15847 }
15848 arg2 = static_cast< bool >(val2);
15849 }
15850 {
15851 PyThreadState* __tstate = wxPyBeginAllowThreads();
15852 result = (arg1)->Mirror(arg2);
15853 wxPyEndAllowThreads(__tstate);
15854 if (PyErr_Occurred()) SWIG_fail;
15855 }
15856 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15857 return resultobj;
15858 fail:
15859 return NULL;
15860 }
15861
15862
15863 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15864 PyObject *resultobj = 0;
15865 wxImage *arg1 = (wxImage *) 0 ;
15866 byte arg2 ;
15867 byte arg3 ;
15868 byte arg4 ;
15869 byte arg5 ;
15870 byte arg6 ;
15871 byte arg7 ;
15872 void *argp1 = 0 ;
15873 int res1 = 0 ;
15874 unsigned char val2 ;
15875 int ecode2 = 0 ;
15876 unsigned char val3 ;
15877 int ecode3 = 0 ;
15878 unsigned char val4 ;
15879 int ecode4 = 0 ;
15880 unsigned char val5 ;
15881 int ecode5 = 0 ;
15882 unsigned char val6 ;
15883 int ecode6 = 0 ;
15884 unsigned char val7 ;
15885 int ecode7 = 0 ;
15886 PyObject * obj0 = 0 ;
15887 PyObject * obj1 = 0 ;
15888 PyObject * obj2 = 0 ;
15889 PyObject * obj3 = 0 ;
15890 PyObject * obj4 = 0 ;
15891 PyObject * obj5 = 0 ;
15892 PyObject * obj6 = 0 ;
15893 char * kwnames[] = {
15894 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15895 };
15896
15897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15901 }
15902 arg1 = reinterpret_cast< wxImage * >(argp1);
15903 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15904 if (!SWIG_IsOK(ecode2)) {
15905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15906 }
15907 arg2 = static_cast< byte >(val2);
15908 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15909 if (!SWIG_IsOK(ecode3)) {
15910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15911 }
15912 arg3 = static_cast< byte >(val3);
15913 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15914 if (!SWIG_IsOK(ecode4)) {
15915 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
15916 }
15917 arg4 = static_cast< byte >(val4);
15918 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15919 if (!SWIG_IsOK(ecode5)) {
15920 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
15921 }
15922 arg5 = static_cast< byte >(val5);
15923 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
15924 if (!SWIG_IsOK(ecode6)) {
15925 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
15926 }
15927 arg6 = static_cast< byte >(val6);
15928 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
15929 if (!SWIG_IsOK(ecode7)) {
15930 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
15931 }
15932 arg7 = static_cast< byte >(val7);
15933 {
15934 PyThreadState* __tstate = wxPyBeginAllowThreads();
15935 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
15936 wxPyEndAllowThreads(__tstate);
15937 if (PyErr_Occurred()) SWIG_fail;
15938 }
15939 resultobj = SWIG_Py_Void();
15940 return resultobj;
15941 fail:
15942 return NULL;
15943 }
15944
15945
15946 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15947 PyObject *resultobj = 0;
15948 wxImage *arg1 = (wxImage *) 0 ;
15949 double arg2 = (double) 0.299 ;
15950 double arg3 = (double) 0.587 ;
15951 double arg4 = (double) 0.114 ;
15952 SwigValueWrapper<wxImage > result;
15953 void *argp1 = 0 ;
15954 int res1 = 0 ;
15955 double val2 ;
15956 int ecode2 = 0 ;
15957 double val3 ;
15958 int ecode3 = 0 ;
15959 double val4 ;
15960 int ecode4 = 0 ;
15961 PyObject * obj0 = 0 ;
15962 PyObject * obj1 = 0 ;
15963 PyObject * obj2 = 0 ;
15964 PyObject * obj3 = 0 ;
15965 char * kwnames[] = {
15966 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
15967 };
15968
15969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15971 if (!SWIG_IsOK(res1)) {
15972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
15973 }
15974 arg1 = reinterpret_cast< wxImage * >(argp1);
15975 if (obj1) {
15976 ecode2 = SWIG_AsVal_double(obj1, &val2);
15977 if (!SWIG_IsOK(ecode2)) {
15978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
15979 }
15980 arg2 = static_cast< double >(val2);
15981 }
15982 if (obj2) {
15983 ecode3 = SWIG_AsVal_double(obj2, &val3);
15984 if (!SWIG_IsOK(ecode3)) {
15985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
15986 }
15987 arg3 = static_cast< double >(val3);
15988 }
15989 if (obj3) {
15990 ecode4 = SWIG_AsVal_double(obj3, &val4);
15991 if (!SWIG_IsOK(ecode4)) {
15992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
15993 }
15994 arg4 = static_cast< double >(val4);
15995 }
15996 {
15997 PyThreadState* __tstate = wxPyBeginAllowThreads();
15998 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
15999 wxPyEndAllowThreads(__tstate);
16000 if (PyErr_Occurred()) SWIG_fail;
16001 }
16002 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16003 return resultobj;
16004 fail:
16005 return NULL;
16006 }
16007
16008
16009 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16010 PyObject *resultobj = 0;
16011 wxImage *arg1 = (wxImage *) 0 ;
16012 byte arg2 ;
16013 byte arg3 ;
16014 byte arg4 ;
16015 SwigValueWrapper<wxImage > result;
16016 void *argp1 = 0 ;
16017 int res1 = 0 ;
16018 unsigned char val2 ;
16019 int ecode2 = 0 ;
16020 unsigned char val3 ;
16021 int ecode3 = 0 ;
16022 unsigned char val4 ;
16023 int ecode4 = 0 ;
16024 PyObject * obj0 = 0 ;
16025 PyObject * obj1 = 0 ;
16026 PyObject * obj2 = 0 ;
16027 PyObject * obj3 = 0 ;
16028 char * kwnames[] = {
16029 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16030 };
16031
16032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16034 if (!SWIG_IsOK(res1)) {
16035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16036 }
16037 arg1 = reinterpret_cast< wxImage * >(argp1);
16038 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16039 if (!SWIG_IsOK(ecode2)) {
16040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16041 }
16042 arg2 = static_cast< byte >(val2);
16043 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16044 if (!SWIG_IsOK(ecode3)) {
16045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16046 }
16047 arg3 = static_cast< byte >(val3);
16048 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16049 if (!SWIG_IsOK(ecode4)) {
16050 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16051 }
16052 arg4 = static_cast< byte >(val4);
16053 {
16054 PyThreadState* __tstate = wxPyBeginAllowThreads();
16055 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16056 wxPyEndAllowThreads(__tstate);
16057 if (PyErr_Occurred()) SWIG_fail;
16058 }
16059 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16060 return resultobj;
16061 fail:
16062 return NULL;
16063 }
16064
16065
16066 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16067 PyObject *resultobj = 0;
16068 wxImage *arg1 = (wxImage *) 0 ;
16069 wxString *arg2 = 0 ;
16070 wxString *arg3 = 0 ;
16071 void *argp1 = 0 ;
16072 int res1 = 0 ;
16073 bool temp2 = false ;
16074 bool temp3 = false ;
16075 PyObject * obj0 = 0 ;
16076 PyObject * obj1 = 0 ;
16077 PyObject * obj2 = 0 ;
16078 char * kwnames[] = {
16079 (char *) "self",(char *) "name",(char *) "value", NULL
16080 };
16081
16082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16084 if (!SWIG_IsOK(res1)) {
16085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16086 }
16087 arg1 = reinterpret_cast< wxImage * >(argp1);
16088 {
16089 arg2 = wxString_in_helper(obj1);
16090 if (arg2 == NULL) SWIG_fail;
16091 temp2 = true;
16092 }
16093 {
16094 arg3 = wxString_in_helper(obj2);
16095 if (arg3 == NULL) SWIG_fail;
16096 temp3 = true;
16097 }
16098 {
16099 PyThreadState* __tstate = wxPyBeginAllowThreads();
16100 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16101 wxPyEndAllowThreads(__tstate);
16102 if (PyErr_Occurred()) SWIG_fail;
16103 }
16104 resultobj = SWIG_Py_Void();
16105 {
16106 if (temp2)
16107 delete arg2;
16108 }
16109 {
16110 if (temp3)
16111 delete arg3;
16112 }
16113 return resultobj;
16114 fail:
16115 {
16116 if (temp2)
16117 delete arg2;
16118 }
16119 {
16120 if (temp3)
16121 delete arg3;
16122 }
16123 return NULL;
16124 }
16125
16126
16127 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16128 PyObject *resultobj = 0;
16129 wxImage *arg1 = (wxImage *) 0 ;
16130 wxString *arg2 = 0 ;
16131 int arg3 ;
16132 void *argp1 = 0 ;
16133 int res1 = 0 ;
16134 bool temp2 = false ;
16135 int val3 ;
16136 int ecode3 = 0 ;
16137 PyObject * obj0 = 0 ;
16138 PyObject * obj1 = 0 ;
16139 PyObject * obj2 = 0 ;
16140 char * kwnames[] = {
16141 (char *) "self",(char *) "name",(char *) "value", NULL
16142 };
16143
16144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16146 if (!SWIG_IsOK(res1)) {
16147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16148 }
16149 arg1 = reinterpret_cast< wxImage * >(argp1);
16150 {
16151 arg2 = wxString_in_helper(obj1);
16152 if (arg2 == NULL) SWIG_fail;
16153 temp2 = true;
16154 }
16155 ecode3 = SWIG_AsVal_int(obj2, &val3);
16156 if (!SWIG_IsOK(ecode3)) {
16157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16158 }
16159 arg3 = static_cast< int >(val3);
16160 {
16161 PyThreadState* __tstate = wxPyBeginAllowThreads();
16162 (arg1)->SetOption((wxString const &)*arg2,arg3);
16163 wxPyEndAllowThreads(__tstate);
16164 if (PyErr_Occurred()) SWIG_fail;
16165 }
16166 resultobj = SWIG_Py_Void();
16167 {
16168 if (temp2)
16169 delete arg2;
16170 }
16171 return resultobj;
16172 fail:
16173 {
16174 if (temp2)
16175 delete arg2;
16176 }
16177 return NULL;
16178 }
16179
16180
16181 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16182 PyObject *resultobj = 0;
16183 wxImage *arg1 = (wxImage *) 0 ;
16184 wxString *arg2 = 0 ;
16185 wxString result;
16186 void *argp1 = 0 ;
16187 int res1 = 0 ;
16188 bool temp2 = false ;
16189 PyObject * obj0 = 0 ;
16190 PyObject * obj1 = 0 ;
16191 char * kwnames[] = {
16192 (char *) "self",(char *) "name", NULL
16193 };
16194
16195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16197 if (!SWIG_IsOK(res1)) {
16198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16199 }
16200 arg1 = reinterpret_cast< wxImage * >(argp1);
16201 {
16202 arg2 = wxString_in_helper(obj1);
16203 if (arg2 == NULL) SWIG_fail;
16204 temp2 = true;
16205 }
16206 {
16207 PyThreadState* __tstate = wxPyBeginAllowThreads();
16208 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16209 wxPyEndAllowThreads(__tstate);
16210 if (PyErr_Occurred()) SWIG_fail;
16211 }
16212 {
16213 #if wxUSE_UNICODE
16214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16215 #else
16216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16217 #endif
16218 }
16219 {
16220 if (temp2)
16221 delete arg2;
16222 }
16223 return resultobj;
16224 fail:
16225 {
16226 if (temp2)
16227 delete arg2;
16228 }
16229 return NULL;
16230 }
16231
16232
16233 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16234 PyObject *resultobj = 0;
16235 wxImage *arg1 = (wxImage *) 0 ;
16236 wxString *arg2 = 0 ;
16237 int result;
16238 void *argp1 = 0 ;
16239 int res1 = 0 ;
16240 bool temp2 = false ;
16241 PyObject * obj0 = 0 ;
16242 PyObject * obj1 = 0 ;
16243 char * kwnames[] = {
16244 (char *) "self",(char *) "name", NULL
16245 };
16246
16247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16249 if (!SWIG_IsOK(res1)) {
16250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16251 }
16252 arg1 = reinterpret_cast< wxImage * >(argp1);
16253 {
16254 arg2 = wxString_in_helper(obj1);
16255 if (arg2 == NULL) SWIG_fail;
16256 temp2 = true;
16257 }
16258 {
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 resultobj = SWIG_From_int(static_cast< int >(result));
16265 {
16266 if (temp2)
16267 delete arg2;
16268 }
16269 return resultobj;
16270 fail:
16271 {
16272 if (temp2)
16273 delete arg2;
16274 }
16275 return NULL;
16276 }
16277
16278
16279 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16280 PyObject *resultobj = 0;
16281 wxImage *arg1 = (wxImage *) 0 ;
16282 wxString *arg2 = 0 ;
16283 bool result;
16284 void *argp1 = 0 ;
16285 int res1 = 0 ;
16286 bool temp2 = false ;
16287 PyObject * obj0 = 0 ;
16288 PyObject * obj1 = 0 ;
16289 char * kwnames[] = {
16290 (char *) "self",(char *) "name", NULL
16291 };
16292
16293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16295 if (!SWIG_IsOK(res1)) {
16296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16297 }
16298 arg1 = reinterpret_cast< wxImage * >(argp1);
16299 {
16300 arg2 = wxString_in_helper(obj1);
16301 if (arg2 == NULL) SWIG_fail;
16302 temp2 = true;
16303 }
16304 {
16305 PyThreadState* __tstate = wxPyBeginAllowThreads();
16306 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16307 wxPyEndAllowThreads(__tstate);
16308 if (PyErr_Occurred()) SWIG_fail;
16309 }
16310 {
16311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16312 }
16313 {
16314 if (temp2)
16315 delete arg2;
16316 }
16317 return resultobj;
16318 fail:
16319 {
16320 if (temp2)
16321 delete arg2;
16322 }
16323 return NULL;
16324 }
16325
16326
16327 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16328 PyObject *resultobj = 0;
16329 wxImage *arg1 = (wxImage *) 0 ;
16330 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16331 unsigned long result;
16332 void *argp1 = 0 ;
16333 int res1 = 0 ;
16334 unsigned long val2 ;
16335 int ecode2 = 0 ;
16336 PyObject * obj0 = 0 ;
16337 PyObject * obj1 = 0 ;
16338 char * kwnames[] = {
16339 (char *) "self",(char *) "stopafter", NULL
16340 };
16341
16342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16344 if (!SWIG_IsOK(res1)) {
16345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16346 }
16347 arg1 = reinterpret_cast< wxImage * >(argp1);
16348 if (obj1) {
16349 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16350 if (!SWIG_IsOK(ecode2)) {
16351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16352 }
16353 arg2 = static_cast< unsigned long >(val2);
16354 }
16355 {
16356 PyThreadState* __tstate = wxPyBeginAllowThreads();
16357 result = (unsigned long)(arg1)->CountColours(arg2);
16358 wxPyEndAllowThreads(__tstate);
16359 if (PyErr_Occurred()) SWIG_fail;
16360 }
16361 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16362 return resultobj;
16363 fail:
16364 return NULL;
16365 }
16366
16367
16368 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16369 PyObject *resultobj = 0;
16370 wxImage *arg1 = (wxImage *) 0 ;
16371 wxImageHistogram *arg2 = 0 ;
16372 unsigned long result;
16373 void *argp1 = 0 ;
16374 int res1 = 0 ;
16375 void *argp2 = 0 ;
16376 int res2 = 0 ;
16377 PyObject * obj0 = 0 ;
16378 PyObject * obj1 = 0 ;
16379 char * kwnames[] = {
16380 (char *) "self",(char *) "h", NULL
16381 };
16382
16383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16385 if (!SWIG_IsOK(res1)) {
16386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16387 }
16388 arg1 = reinterpret_cast< wxImage * >(argp1);
16389 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16390 if (!SWIG_IsOK(res2)) {
16391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16392 }
16393 if (!argp2) {
16394 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16395 }
16396 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16397 {
16398 PyThreadState* __tstate = wxPyBeginAllowThreads();
16399 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16400 wxPyEndAllowThreads(__tstate);
16401 if (PyErr_Occurred()) SWIG_fail;
16402 }
16403 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16404 return resultobj;
16405 fail:
16406 return NULL;
16407 }
16408
16409
16410 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16411 PyObject *resultobj = 0;
16412 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16413 void *argp1 = 0 ;
16414 int res1 = 0 ;
16415 PyObject * obj0 = 0 ;
16416 char * kwnames[] = {
16417 (char *) "handler", NULL
16418 };
16419
16420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16422 if (!SWIG_IsOK(res1)) {
16423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16424 }
16425 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16426 {
16427 PyThreadState* __tstate = wxPyBeginAllowThreads();
16428 wxImage::AddHandler(arg1);
16429 wxPyEndAllowThreads(__tstate);
16430 if (PyErr_Occurred()) SWIG_fail;
16431 }
16432 resultobj = SWIG_Py_Void();
16433 return resultobj;
16434 fail:
16435 return NULL;
16436 }
16437
16438
16439 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16440 PyObject *resultobj = 0;
16441 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16442 void *argp1 = 0 ;
16443 int res1 = 0 ;
16444 PyObject * obj0 = 0 ;
16445 char * kwnames[] = {
16446 (char *) "handler", NULL
16447 };
16448
16449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16451 if (!SWIG_IsOK(res1)) {
16452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16453 }
16454 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16455 {
16456 PyThreadState* __tstate = wxPyBeginAllowThreads();
16457 wxImage::InsertHandler(arg1);
16458 wxPyEndAllowThreads(__tstate);
16459 if (PyErr_Occurred()) SWIG_fail;
16460 }
16461 resultobj = SWIG_Py_Void();
16462 return resultobj;
16463 fail:
16464 return NULL;
16465 }
16466
16467
16468 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16469 PyObject *resultobj = 0;
16470 wxString *arg1 = 0 ;
16471 bool result;
16472 bool temp1 = false ;
16473 PyObject * obj0 = 0 ;
16474 char * kwnames[] = {
16475 (char *) "name", NULL
16476 };
16477
16478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16479 {
16480 arg1 = wxString_in_helper(obj0);
16481 if (arg1 == NULL) SWIG_fail;
16482 temp1 = true;
16483 }
16484 {
16485 PyThreadState* __tstate = wxPyBeginAllowThreads();
16486 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16487 wxPyEndAllowThreads(__tstate);
16488 if (PyErr_Occurred()) SWIG_fail;
16489 }
16490 {
16491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16492 }
16493 {
16494 if (temp1)
16495 delete arg1;
16496 }
16497 return resultobj;
16498 fail:
16499 {
16500 if (temp1)
16501 delete arg1;
16502 }
16503 return NULL;
16504 }
16505
16506
16507 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16508 PyObject *resultobj = 0;
16509 PyObject *result = 0 ;
16510
16511 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 result = (PyObject *)wxImage_GetHandlers();
16515 wxPyEndAllowThreads(__tstate);
16516 if (PyErr_Occurred()) SWIG_fail;
16517 }
16518 resultobj = result;
16519 return resultobj;
16520 fail:
16521 return NULL;
16522 }
16523
16524
16525 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16526 PyObject *resultobj = 0;
16527 wxString result;
16528
16529 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16530 {
16531 PyThreadState* __tstate = wxPyBeginAllowThreads();
16532 result = wxImage::GetImageExtWildcard();
16533 wxPyEndAllowThreads(__tstate);
16534 if (PyErr_Occurred()) SWIG_fail;
16535 }
16536 {
16537 #if wxUSE_UNICODE
16538 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16539 #else
16540 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16541 #endif
16542 }
16543 return resultobj;
16544 fail:
16545 return NULL;
16546 }
16547
16548
16549 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16550 PyObject *resultobj = 0;
16551 wxImage *arg1 = (wxImage *) 0 ;
16552 int arg2 = (int) -1 ;
16553 wxBitmap result;
16554 void *argp1 = 0 ;
16555 int res1 = 0 ;
16556 int val2 ;
16557 int ecode2 = 0 ;
16558 PyObject * obj0 = 0 ;
16559 PyObject * obj1 = 0 ;
16560 char * kwnames[] = {
16561 (char *) "self",(char *) "depth", NULL
16562 };
16563
16564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16566 if (!SWIG_IsOK(res1)) {
16567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16568 }
16569 arg1 = reinterpret_cast< wxImage * >(argp1);
16570 if (obj1) {
16571 ecode2 = SWIG_AsVal_int(obj1, &val2);
16572 if (!SWIG_IsOK(ecode2)) {
16573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16574 }
16575 arg2 = static_cast< int >(val2);
16576 }
16577 {
16578 if (!wxPyCheckForApp()) SWIG_fail;
16579 PyThreadState* __tstate = wxPyBeginAllowThreads();
16580 result = wxImage_ConvertToBitmap(arg1,arg2);
16581 wxPyEndAllowThreads(__tstate);
16582 if (PyErr_Occurred()) SWIG_fail;
16583 }
16584 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16585 return resultobj;
16586 fail:
16587 return NULL;
16588 }
16589
16590
16591 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16592 PyObject *resultobj = 0;
16593 wxImage *arg1 = (wxImage *) 0 ;
16594 byte arg2 ;
16595 byte arg3 ;
16596 byte arg4 ;
16597 wxBitmap result;
16598 void *argp1 = 0 ;
16599 int res1 = 0 ;
16600 unsigned char val2 ;
16601 int ecode2 = 0 ;
16602 unsigned char val3 ;
16603 int ecode3 = 0 ;
16604 unsigned char val4 ;
16605 int ecode4 = 0 ;
16606 PyObject * obj0 = 0 ;
16607 PyObject * obj1 = 0 ;
16608 PyObject * obj2 = 0 ;
16609 PyObject * obj3 = 0 ;
16610 char * kwnames[] = {
16611 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16612 };
16613
16614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16616 if (!SWIG_IsOK(res1)) {
16617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16618 }
16619 arg1 = reinterpret_cast< wxImage * >(argp1);
16620 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16621 if (!SWIG_IsOK(ecode2)) {
16622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16623 }
16624 arg2 = static_cast< byte >(val2);
16625 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16626 if (!SWIG_IsOK(ecode3)) {
16627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16628 }
16629 arg3 = static_cast< byte >(val3);
16630 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16631 if (!SWIG_IsOK(ecode4)) {
16632 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16633 }
16634 arg4 = static_cast< byte >(val4);
16635 {
16636 if (!wxPyCheckForApp()) SWIG_fail;
16637 PyThreadState* __tstate = wxPyBeginAllowThreads();
16638 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16639 wxPyEndAllowThreads(__tstate);
16640 if (PyErr_Occurred()) SWIG_fail;
16641 }
16642 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16643 return resultobj;
16644 fail:
16645 return NULL;
16646 }
16647
16648
16649 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16650 PyObject *resultobj = 0;
16651 wxImage *arg1 = (wxImage *) 0 ;
16652 double arg2 ;
16653 void *argp1 = 0 ;
16654 int res1 = 0 ;
16655 double val2 ;
16656 int ecode2 = 0 ;
16657 PyObject * obj0 = 0 ;
16658 PyObject * obj1 = 0 ;
16659 char * kwnames[] = {
16660 (char *) "self",(char *) "angle", NULL
16661 };
16662
16663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16665 if (!SWIG_IsOK(res1)) {
16666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16667 }
16668 arg1 = reinterpret_cast< wxImage * >(argp1);
16669 ecode2 = SWIG_AsVal_double(obj1, &val2);
16670 if (!SWIG_IsOK(ecode2)) {
16671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16672 }
16673 arg2 = static_cast< double >(val2);
16674 {
16675 PyThreadState* __tstate = wxPyBeginAllowThreads();
16676 (arg1)->RotateHue(arg2);
16677 wxPyEndAllowThreads(__tstate);
16678 if (PyErr_Occurred()) SWIG_fail;
16679 }
16680 resultobj = SWIG_Py_Void();
16681 return resultobj;
16682 fail:
16683 return NULL;
16684 }
16685
16686
16687 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16688 PyObject *resultobj = 0;
16689 wxImage_RGBValue arg1 ;
16690 wxImage_HSVValue result;
16691 void *argp1 ;
16692 int res1 = 0 ;
16693 PyObject * obj0 = 0 ;
16694 char * kwnames[] = {
16695 (char *) "rgb", NULL
16696 };
16697
16698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16699 {
16700 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16701 if (!SWIG_IsOK(res1)) {
16702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16703 }
16704 if (!argp1) {
16705 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16706 } else {
16707 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16708 arg1 = *temp;
16709 if (SWIG_IsNewObj(res1)) delete temp;
16710 }
16711 }
16712 {
16713 PyThreadState* __tstate = wxPyBeginAllowThreads();
16714 result = wxImage::RGBtoHSV(arg1);
16715 wxPyEndAllowThreads(__tstate);
16716 if (PyErr_Occurred()) SWIG_fail;
16717 }
16718 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16719 return resultobj;
16720 fail:
16721 return NULL;
16722 }
16723
16724
16725 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16726 PyObject *resultobj = 0;
16727 wxImage_HSVValue arg1 ;
16728 wxImage_RGBValue result;
16729 void *argp1 ;
16730 int res1 = 0 ;
16731 PyObject * obj0 = 0 ;
16732 char * kwnames[] = {
16733 (char *) "hsv", NULL
16734 };
16735
16736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16737 {
16738 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16739 if (!SWIG_IsOK(res1)) {
16740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16741 }
16742 if (!argp1) {
16743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16744 } else {
16745 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16746 arg1 = *temp;
16747 if (SWIG_IsNewObj(res1)) delete temp;
16748 }
16749 }
16750 {
16751 PyThreadState* __tstate = wxPyBeginAllowThreads();
16752 result = wxImage::HSVtoRGB(arg1);
16753 wxPyEndAllowThreads(__tstate);
16754 if (PyErr_Occurred()) SWIG_fail;
16755 }
16756 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16757 return resultobj;
16758 fail:
16759 return NULL;
16760 }
16761
16762
16763 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16764 PyObject *obj;
16765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16766 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16767 return SWIG_Py_Void();
16768 }
16769
16770 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16771 return SWIG_Python_InitShadowInstance(args);
16772 }
16773
16774 SWIGINTERN int NullImage_set(PyObject *) {
16775 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16776 return 1;
16777 }
16778
16779
16780 SWIGINTERN PyObject *NullImage_get(void) {
16781 PyObject *pyobj = 0;
16782
16783 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16784 return pyobj;
16785 }
16786
16787
16788 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16789 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16790 return 1;
16791 }
16792
16793
16794 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16795 PyObject *pyobj = 0;
16796
16797 {
16798 #if wxUSE_UNICODE
16799 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16800 #else
16801 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16802 #endif
16803 }
16804 return pyobj;
16805 }
16806
16807
16808 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16809 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16810 return 1;
16811 }
16812
16813
16814 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16815 PyObject *pyobj = 0;
16816
16817 {
16818 #if wxUSE_UNICODE
16819 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16820 #else
16821 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16822 #endif
16823 }
16824 return pyobj;
16825 }
16826
16827
16828 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16829 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16830 return 1;
16831 }
16832
16833
16834 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16835 PyObject *pyobj = 0;
16836
16837 {
16838 #if wxUSE_UNICODE
16839 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16840 #else
16841 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16842 #endif
16843 }
16844 return pyobj;
16845 }
16846
16847
16848 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16849 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16850 return 1;
16851 }
16852
16853
16854 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16855 PyObject *pyobj = 0;
16856
16857 {
16858 #if wxUSE_UNICODE
16859 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16860 #else
16861 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16862 #endif
16863 }
16864 return pyobj;
16865 }
16866
16867
16868 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16869 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16870 return 1;
16871 }
16872
16873
16874 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16875 PyObject *pyobj = 0;
16876
16877 {
16878 #if wxUSE_UNICODE
16879 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16880 #else
16881 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16882 #endif
16883 }
16884 return pyobj;
16885 }
16886
16887
16888 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16889 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16890 return 1;
16891 }
16892
16893
16894 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16895 PyObject *pyobj = 0;
16896
16897 {
16898 #if wxUSE_UNICODE
16899 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16900 #else
16901 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16902 #endif
16903 }
16904 return pyobj;
16905 }
16906
16907
16908 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16909 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16910 return 1;
16911 }
16912
16913
16914 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16915 PyObject *pyobj = 0;
16916
16917 {
16918 #if wxUSE_UNICODE
16919 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16920 #else
16921 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16922 #endif
16923 }
16924 return pyobj;
16925 }
16926
16927
16928 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
16929 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
16930 return 1;
16931 }
16932
16933
16934 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
16935 PyObject *pyobj = 0;
16936
16937 {
16938 #if wxUSE_UNICODE
16939 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16940 #else
16941 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16942 #endif
16943 }
16944 return pyobj;
16945 }
16946
16947
16948 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
16949 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
16950 return 1;
16951 }
16952
16953
16954 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
16955 PyObject *pyobj = 0;
16956
16957 {
16958 #if wxUSE_UNICODE
16959 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16960 #else
16961 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16962 #endif
16963 }
16964 return pyobj;
16965 }
16966
16967
16968 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
16969 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
16970 return 1;
16971 }
16972
16973
16974 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
16975 PyObject *pyobj = 0;
16976
16977 {
16978 #if wxUSE_UNICODE
16979 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
16980 #else
16981 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
16982 #endif
16983 }
16984 return pyobj;
16985 }
16986
16987
16988 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
16989 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
16990 return 1;
16991 }
16992
16993
16994 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
16995 PyObject *pyobj = 0;
16996
16997 {
16998 #if wxUSE_UNICODE
16999 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17000 #else
17001 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17002 #endif
17003 }
17004 return pyobj;
17005 }
17006
17007
17008 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17009 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17010 return 1;
17011 }
17012
17013
17014 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17015 PyObject *pyobj = 0;
17016
17017 {
17018 #if wxUSE_UNICODE
17019 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17020 #else
17021 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17022 #endif
17023 }
17024 return pyobj;
17025 }
17026
17027
17028 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17029 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17030 return 1;
17031 }
17032
17033
17034 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17035 PyObject *pyobj = 0;
17036
17037 {
17038 #if wxUSE_UNICODE
17039 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17040 #else
17041 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17042 #endif
17043 }
17044 return pyobj;
17045 }
17046
17047
17048 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17049 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17050 return 1;
17051 }
17052
17053
17054 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17055 PyObject *pyobj = 0;
17056
17057 {
17058 #if wxUSE_UNICODE
17059 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17060 #else
17061 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17062 #endif
17063 }
17064 return pyobj;
17065 }
17066
17067
17068 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17069 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17070 return 1;
17071 }
17072
17073
17074 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17075 PyObject *pyobj = 0;
17076
17077 {
17078 #if wxUSE_UNICODE
17079 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17080 #else
17081 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17082 #endif
17083 }
17084 return pyobj;
17085 }
17086
17087
17088 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17089 PyObject *resultobj = 0;
17090 wxBMPHandler *result = 0 ;
17091
17092 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17093 {
17094 PyThreadState* __tstate = wxPyBeginAllowThreads();
17095 result = (wxBMPHandler *)new wxBMPHandler();
17096 wxPyEndAllowThreads(__tstate);
17097 if (PyErr_Occurred()) SWIG_fail;
17098 }
17099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17100 return resultobj;
17101 fail:
17102 return NULL;
17103 }
17104
17105
17106 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17107 PyObject *obj;
17108 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17109 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17110 return SWIG_Py_Void();
17111 }
17112
17113 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17114 return SWIG_Python_InitShadowInstance(args);
17115 }
17116
17117 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17118 PyObject *resultobj = 0;
17119 wxICOHandler *result = 0 ;
17120
17121 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17122 {
17123 PyThreadState* __tstate = wxPyBeginAllowThreads();
17124 result = (wxICOHandler *)new wxICOHandler();
17125 wxPyEndAllowThreads(__tstate);
17126 if (PyErr_Occurred()) SWIG_fail;
17127 }
17128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17129 return resultobj;
17130 fail:
17131 return NULL;
17132 }
17133
17134
17135 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17136 PyObject *obj;
17137 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17138 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17139 return SWIG_Py_Void();
17140 }
17141
17142 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17143 return SWIG_Python_InitShadowInstance(args);
17144 }
17145
17146 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17147 PyObject *resultobj = 0;
17148 wxCURHandler *result = 0 ;
17149
17150 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17151 {
17152 PyThreadState* __tstate = wxPyBeginAllowThreads();
17153 result = (wxCURHandler *)new wxCURHandler();
17154 wxPyEndAllowThreads(__tstate);
17155 if (PyErr_Occurred()) SWIG_fail;
17156 }
17157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17158 return resultobj;
17159 fail:
17160 return NULL;
17161 }
17162
17163
17164 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17165 PyObject *obj;
17166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17167 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17168 return SWIG_Py_Void();
17169 }
17170
17171 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17172 return SWIG_Python_InitShadowInstance(args);
17173 }
17174
17175 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17176 PyObject *resultobj = 0;
17177 wxANIHandler *result = 0 ;
17178
17179 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17180 {
17181 PyThreadState* __tstate = wxPyBeginAllowThreads();
17182 result = (wxANIHandler *)new wxANIHandler();
17183 wxPyEndAllowThreads(__tstate);
17184 if (PyErr_Occurred()) SWIG_fail;
17185 }
17186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17187 return resultobj;
17188 fail:
17189 return NULL;
17190 }
17191
17192
17193 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17194 PyObject *obj;
17195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17196 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17197 return SWIG_Py_Void();
17198 }
17199
17200 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17201 return SWIG_Python_InitShadowInstance(args);
17202 }
17203
17204 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17205 PyObject *resultobj = 0;
17206 wxPNGHandler *result = 0 ;
17207
17208 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17209 {
17210 PyThreadState* __tstate = wxPyBeginAllowThreads();
17211 result = (wxPNGHandler *)new wxPNGHandler();
17212 wxPyEndAllowThreads(__tstate);
17213 if (PyErr_Occurred()) SWIG_fail;
17214 }
17215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17216 return resultobj;
17217 fail:
17218 return NULL;
17219 }
17220
17221
17222 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17223 PyObject *obj;
17224 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17225 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17226 return SWIG_Py_Void();
17227 }
17228
17229 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17230 return SWIG_Python_InitShadowInstance(args);
17231 }
17232
17233 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17234 PyObject *resultobj = 0;
17235 wxGIFHandler *result = 0 ;
17236
17237 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17238 {
17239 PyThreadState* __tstate = wxPyBeginAllowThreads();
17240 result = (wxGIFHandler *)new wxGIFHandler();
17241 wxPyEndAllowThreads(__tstate);
17242 if (PyErr_Occurred()) SWIG_fail;
17243 }
17244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17245 return resultobj;
17246 fail:
17247 return NULL;
17248 }
17249
17250
17251 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17252 PyObject *obj;
17253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17254 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17255 return SWIG_Py_Void();
17256 }
17257
17258 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17259 return SWIG_Python_InitShadowInstance(args);
17260 }
17261
17262 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17263 PyObject *resultobj = 0;
17264 wxPCXHandler *result = 0 ;
17265
17266 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17267 {
17268 PyThreadState* __tstate = wxPyBeginAllowThreads();
17269 result = (wxPCXHandler *)new wxPCXHandler();
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17274 return resultobj;
17275 fail:
17276 return NULL;
17277 }
17278
17279
17280 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17281 PyObject *obj;
17282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17283 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17284 return SWIG_Py_Void();
17285 }
17286
17287 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17288 return SWIG_Python_InitShadowInstance(args);
17289 }
17290
17291 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17292 PyObject *resultobj = 0;
17293 wxJPEGHandler *result = 0 ;
17294
17295 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17296 {
17297 PyThreadState* __tstate = wxPyBeginAllowThreads();
17298 result = (wxJPEGHandler *)new wxJPEGHandler();
17299 wxPyEndAllowThreads(__tstate);
17300 if (PyErr_Occurred()) SWIG_fail;
17301 }
17302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17303 return resultobj;
17304 fail:
17305 return NULL;
17306 }
17307
17308
17309 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17310 PyObject *obj;
17311 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17312 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17313 return SWIG_Py_Void();
17314 }
17315
17316 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17317 return SWIG_Python_InitShadowInstance(args);
17318 }
17319
17320 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17321 PyObject *resultobj = 0;
17322 wxPNMHandler *result = 0 ;
17323
17324 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17325 {
17326 PyThreadState* __tstate = wxPyBeginAllowThreads();
17327 result = (wxPNMHandler *)new wxPNMHandler();
17328 wxPyEndAllowThreads(__tstate);
17329 if (PyErr_Occurred()) SWIG_fail;
17330 }
17331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17332 return resultobj;
17333 fail:
17334 return NULL;
17335 }
17336
17337
17338 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17339 PyObject *obj;
17340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17341 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17342 return SWIG_Py_Void();
17343 }
17344
17345 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17346 return SWIG_Python_InitShadowInstance(args);
17347 }
17348
17349 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17350 PyObject *resultobj = 0;
17351 wxXPMHandler *result = 0 ;
17352
17353 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17354 {
17355 PyThreadState* __tstate = wxPyBeginAllowThreads();
17356 result = (wxXPMHandler *)new wxXPMHandler();
17357 wxPyEndAllowThreads(__tstate);
17358 if (PyErr_Occurred()) SWIG_fail;
17359 }
17360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17361 return resultobj;
17362 fail:
17363 return NULL;
17364 }
17365
17366
17367 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17368 PyObject *obj;
17369 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17370 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17371 return SWIG_Py_Void();
17372 }
17373
17374 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17375 return SWIG_Python_InitShadowInstance(args);
17376 }
17377
17378 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17379 PyObject *resultobj = 0;
17380 wxTIFFHandler *result = 0 ;
17381
17382 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17383 {
17384 PyThreadState* __tstate = wxPyBeginAllowThreads();
17385 result = (wxTIFFHandler *)new wxTIFFHandler();
17386 wxPyEndAllowThreads(__tstate);
17387 if (PyErr_Occurred()) SWIG_fail;
17388 }
17389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17390 return resultobj;
17391 fail:
17392 return NULL;
17393 }
17394
17395
17396 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17397 PyObject *obj;
17398 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17399 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17400 return SWIG_Py_Void();
17401 }
17402
17403 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17404 return SWIG_Python_InitShadowInstance(args);
17405 }
17406
17407 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17408 PyObject *resultobj = 0;
17409 wxImage *arg1 = 0 ;
17410 wxImage *arg2 = 0 ;
17411 int arg3 = (int) 236 ;
17412 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17413 bool result;
17414 void *argp1 = 0 ;
17415 int res1 = 0 ;
17416 void *argp2 = 0 ;
17417 int res2 = 0 ;
17418 int val3 ;
17419 int ecode3 = 0 ;
17420 int val4 ;
17421 int ecode4 = 0 ;
17422 PyObject * obj0 = 0 ;
17423 PyObject * obj1 = 0 ;
17424 PyObject * obj2 = 0 ;
17425 PyObject * obj3 = 0 ;
17426 char * kwnames[] = {
17427 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17428 };
17429
17430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17431 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17432 if (!SWIG_IsOK(res1)) {
17433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17434 }
17435 if (!argp1) {
17436 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17437 }
17438 arg1 = reinterpret_cast< wxImage * >(argp1);
17439 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17440 if (!SWIG_IsOK(res2)) {
17441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17442 }
17443 if (!argp2) {
17444 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17445 }
17446 arg2 = reinterpret_cast< wxImage * >(argp2);
17447 if (obj2) {
17448 ecode3 = SWIG_AsVal_int(obj2, &val3);
17449 if (!SWIG_IsOK(ecode3)) {
17450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17451 }
17452 arg3 = static_cast< int >(val3);
17453 }
17454 if (obj3) {
17455 ecode4 = SWIG_AsVal_int(obj3, &val4);
17456 if (!SWIG_IsOK(ecode4)) {
17457 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17458 }
17459 arg4 = static_cast< int >(val4);
17460 }
17461 {
17462 PyThreadState* __tstate = wxPyBeginAllowThreads();
17463 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17464 wxPyEndAllowThreads(__tstate);
17465 if (PyErr_Occurred()) SWIG_fail;
17466 }
17467 {
17468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17469 }
17470 return resultobj;
17471 fail:
17472 return NULL;
17473 }
17474
17475
17476 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17477 PyObject *obj;
17478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17479 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17480 return SWIG_Py_Void();
17481 }
17482
17483 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17484 PyObject *resultobj = 0;
17485 wxEvtHandler *result = 0 ;
17486
17487 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17488 {
17489 PyThreadState* __tstate = wxPyBeginAllowThreads();
17490 result = (wxEvtHandler *)new wxEvtHandler();
17491 wxPyEndAllowThreads(__tstate);
17492 if (PyErr_Occurred()) SWIG_fail;
17493 }
17494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17495 return resultobj;
17496 fail:
17497 return NULL;
17498 }
17499
17500
17501 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17502 PyObject *resultobj = 0;
17503 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17504 wxEvtHandler *result = 0 ;
17505 void *argp1 = 0 ;
17506 int res1 = 0 ;
17507 PyObject *swig_obj[1] ;
17508
17509 if (!args) SWIG_fail;
17510 swig_obj[0] = args;
17511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17512 if (!SWIG_IsOK(res1)) {
17513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17514 }
17515 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17516 {
17517 PyThreadState* __tstate = wxPyBeginAllowThreads();
17518 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17519 wxPyEndAllowThreads(__tstate);
17520 if (PyErr_Occurred()) SWIG_fail;
17521 }
17522 {
17523 resultobj = wxPyMake_wxObject(result, 0);
17524 }
17525 return resultobj;
17526 fail:
17527 return NULL;
17528 }
17529
17530
17531 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17532 PyObject *resultobj = 0;
17533 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17534 wxEvtHandler *result = 0 ;
17535 void *argp1 = 0 ;
17536 int res1 = 0 ;
17537 PyObject *swig_obj[1] ;
17538
17539 if (!args) SWIG_fail;
17540 swig_obj[0] = args;
17541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17542 if (!SWIG_IsOK(res1)) {
17543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17544 }
17545 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17546 {
17547 PyThreadState* __tstate = wxPyBeginAllowThreads();
17548 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17549 wxPyEndAllowThreads(__tstate);
17550 if (PyErr_Occurred()) SWIG_fail;
17551 }
17552 {
17553 resultobj = wxPyMake_wxObject(result, 0);
17554 }
17555 return resultobj;
17556 fail:
17557 return NULL;
17558 }
17559
17560
17561 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17562 PyObject *resultobj = 0;
17563 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17564 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17565 void *argp1 = 0 ;
17566 int res1 = 0 ;
17567 void *argp2 = 0 ;
17568 int res2 = 0 ;
17569 PyObject * obj0 = 0 ;
17570 PyObject * obj1 = 0 ;
17571 char * kwnames[] = {
17572 (char *) "self",(char *) "handler", NULL
17573 };
17574
17575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17577 if (!SWIG_IsOK(res1)) {
17578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17579 }
17580 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17581 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17582 if (!SWIG_IsOK(res2)) {
17583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17584 }
17585 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17586 {
17587 PyThreadState* __tstate = wxPyBeginAllowThreads();
17588 (arg1)->SetNextHandler(arg2);
17589 wxPyEndAllowThreads(__tstate);
17590 if (PyErr_Occurred()) SWIG_fail;
17591 }
17592 resultobj = SWIG_Py_Void();
17593 return resultobj;
17594 fail:
17595 return NULL;
17596 }
17597
17598
17599 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17600 PyObject *resultobj = 0;
17601 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17602 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17603 void *argp1 = 0 ;
17604 int res1 = 0 ;
17605 void *argp2 = 0 ;
17606 int res2 = 0 ;
17607 PyObject * obj0 = 0 ;
17608 PyObject * obj1 = 0 ;
17609 char * kwnames[] = {
17610 (char *) "self",(char *) "handler", NULL
17611 };
17612
17613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17615 if (!SWIG_IsOK(res1)) {
17616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17617 }
17618 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17619 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17620 if (!SWIG_IsOK(res2)) {
17621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17622 }
17623 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17624 {
17625 PyThreadState* __tstate = wxPyBeginAllowThreads();
17626 (arg1)->SetPreviousHandler(arg2);
17627 wxPyEndAllowThreads(__tstate);
17628 if (PyErr_Occurred()) SWIG_fail;
17629 }
17630 resultobj = SWIG_Py_Void();
17631 return resultobj;
17632 fail:
17633 return NULL;
17634 }
17635
17636
17637 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17638 PyObject *resultobj = 0;
17639 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17640 bool result;
17641 void *argp1 = 0 ;
17642 int res1 = 0 ;
17643 PyObject *swig_obj[1] ;
17644
17645 if (!args) SWIG_fail;
17646 swig_obj[0] = args;
17647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17648 if (!SWIG_IsOK(res1)) {
17649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17650 }
17651 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17652 {
17653 PyThreadState* __tstate = wxPyBeginAllowThreads();
17654 result = (bool)(arg1)->GetEvtHandlerEnabled();
17655 wxPyEndAllowThreads(__tstate);
17656 if (PyErr_Occurred()) SWIG_fail;
17657 }
17658 {
17659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17660 }
17661 return resultobj;
17662 fail:
17663 return NULL;
17664 }
17665
17666
17667 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17668 PyObject *resultobj = 0;
17669 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17670 bool arg2 ;
17671 void *argp1 = 0 ;
17672 int res1 = 0 ;
17673 bool val2 ;
17674 int ecode2 = 0 ;
17675 PyObject * obj0 = 0 ;
17676 PyObject * obj1 = 0 ;
17677 char * kwnames[] = {
17678 (char *) "self",(char *) "enabled", NULL
17679 };
17680
17681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17683 if (!SWIG_IsOK(res1)) {
17684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17685 }
17686 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17687 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17688 if (!SWIG_IsOK(ecode2)) {
17689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17690 }
17691 arg2 = static_cast< bool >(val2);
17692 {
17693 PyThreadState* __tstate = wxPyBeginAllowThreads();
17694 (arg1)->SetEvtHandlerEnabled(arg2);
17695 wxPyEndAllowThreads(__tstate);
17696 if (PyErr_Occurred()) SWIG_fail;
17697 }
17698 resultobj = SWIG_Py_Void();
17699 return resultobj;
17700 fail:
17701 return NULL;
17702 }
17703
17704
17705 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17706 PyObject *resultobj = 0;
17707 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17708 wxEvent *arg2 = 0 ;
17709 bool result;
17710 void *argp1 = 0 ;
17711 int res1 = 0 ;
17712 void *argp2 = 0 ;
17713 int res2 = 0 ;
17714 PyObject * obj0 = 0 ;
17715 PyObject * obj1 = 0 ;
17716 char * kwnames[] = {
17717 (char *) "self",(char *) "event", NULL
17718 };
17719
17720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17722 if (!SWIG_IsOK(res1)) {
17723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17724 }
17725 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17726 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17727 if (!SWIG_IsOK(res2)) {
17728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17729 }
17730 if (!argp2) {
17731 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17732 }
17733 arg2 = reinterpret_cast< wxEvent * >(argp2);
17734 {
17735 PyThreadState* __tstate = wxPyBeginAllowThreads();
17736 result = (bool)(arg1)->ProcessEvent(*arg2);
17737 wxPyEndAllowThreads(__tstate);
17738 if (PyErr_Occurred()) SWIG_fail;
17739 }
17740 {
17741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17742 }
17743 return resultobj;
17744 fail:
17745 return NULL;
17746 }
17747
17748
17749 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17750 PyObject *resultobj = 0;
17751 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17752 wxEvent *arg2 = 0 ;
17753 void *argp1 = 0 ;
17754 int res1 = 0 ;
17755 void *argp2 = 0 ;
17756 int res2 = 0 ;
17757 PyObject * obj0 = 0 ;
17758 PyObject * obj1 = 0 ;
17759 char * kwnames[] = {
17760 (char *) "self",(char *) "event", NULL
17761 };
17762
17763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17765 if (!SWIG_IsOK(res1)) {
17766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17767 }
17768 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17769 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17770 if (!SWIG_IsOK(res2)) {
17771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17772 }
17773 if (!argp2) {
17774 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17775 }
17776 arg2 = reinterpret_cast< wxEvent * >(argp2);
17777 {
17778 PyThreadState* __tstate = wxPyBeginAllowThreads();
17779 (arg1)->AddPendingEvent(*arg2);
17780 wxPyEndAllowThreads(__tstate);
17781 if (PyErr_Occurred()) SWIG_fail;
17782 }
17783 resultobj = SWIG_Py_Void();
17784 return resultobj;
17785 fail:
17786 return NULL;
17787 }
17788
17789
17790 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17791 PyObject *resultobj = 0;
17792 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17793 void *argp1 = 0 ;
17794 int res1 = 0 ;
17795 PyObject *swig_obj[1] ;
17796
17797 if (!args) SWIG_fail;
17798 swig_obj[0] = args;
17799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17800 if (!SWIG_IsOK(res1)) {
17801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17802 }
17803 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17804 {
17805 PyThreadState* __tstate = wxPyBeginAllowThreads();
17806 (arg1)->ProcessPendingEvents();
17807 wxPyEndAllowThreads(__tstate);
17808 if (PyErr_Occurred()) SWIG_fail;
17809 }
17810 resultobj = SWIG_Py_Void();
17811 return resultobj;
17812 fail:
17813 return NULL;
17814 }
17815
17816
17817 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17818 PyObject *resultobj = 0;
17819 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17820 int arg2 ;
17821 int arg3 ;
17822 int arg4 ;
17823 PyObject *arg5 = (PyObject *) 0 ;
17824 void *argp1 = 0 ;
17825 int res1 = 0 ;
17826 int val2 ;
17827 int ecode2 = 0 ;
17828 int val3 ;
17829 int ecode3 = 0 ;
17830 int val4 ;
17831 int ecode4 = 0 ;
17832 PyObject * obj0 = 0 ;
17833 PyObject * obj1 = 0 ;
17834 PyObject * obj2 = 0 ;
17835 PyObject * obj3 = 0 ;
17836 PyObject * obj4 = 0 ;
17837 char * kwnames[] = {
17838 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17839 };
17840
17841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17843 if (!SWIG_IsOK(res1)) {
17844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17845 }
17846 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17847 ecode2 = SWIG_AsVal_int(obj1, &val2);
17848 if (!SWIG_IsOK(ecode2)) {
17849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17850 }
17851 arg2 = static_cast< int >(val2);
17852 ecode3 = SWIG_AsVal_int(obj2, &val3);
17853 if (!SWIG_IsOK(ecode3)) {
17854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17855 }
17856 arg3 = static_cast< int >(val3);
17857 ecode4 = SWIG_AsVal_int(obj3, &val4);
17858 if (!SWIG_IsOK(ecode4)) {
17859 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17860 }
17861 arg4 = static_cast< int >(val4);
17862 arg5 = obj4;
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17866 wxPyEndAllowThreads(__tstate);
17867 if (PyErr_Occurred()) SWIG_fail;
17868 }
17869 resultobj = SWIG_Py_Void();
17870 return resultobj;
17871 fail:
17872 return NULL;
17873 }
17874
17875
17876 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17877 PyObject *resultobj = 0;
17878 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17879 int arg2 ;
17880 int arg3 = (int) -1 ;
17881 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17882 bool result;
17883 void *argp1 = 0 ;
17884 int res1 = 0 ;
17885 int val2 ;
17886 int ecode2 = 0 ;
17887 int val3 ;
17888 int ecode3 = 0 ;
17889 int val4 ;
17890 int ecode4 = 0 ;
17891 PyObject * obj0 = 0 ;
17892 PyObject * obj1 = 0 ;
17893 PyObject * obj2 = 0 ;
17894 PyObject * obj3 = 0 ;
17895 char * kwnames[] = {
17896 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17897 };
17898
17899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17901 if (!SWIG_IsOK(res1)) {
17902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17903 }
17904 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17905 ecode2 = SWIG_AsVal_int(obj1, &val2);
17906 if (!SWIG_IsOK(ecode2)) {
17907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17908 }
17909 arg2 = static_cast< int >(val2);
17910 if (obj2) {
17911 ecode3 = SWIG_AsVal_int(obj2, &val3);
17912 if (!SWIG_IsOK(ecode3)) {
17913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17914 }
17915 arg3 = static_cast< int >(val3);
17916 }
17917 if (obj3) {
17918 ecode4 = SWIG_AsVal_int(obj3, &val4);
17919 if (!SWIG_IsOK(ecode4)) {
17920 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
17921 }
17922 arg4 = static_cast< wxEventType >(val4);
17923 }
17924 {
17925 PyThreadState* __tstate = wxPyBeginAllowThreads();
17926 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
17927 wxPyEndAllowThreads(__tstate);
17928 if (PyErr_Occurred()) SWIG_fail;
17929 }
17930 {
17931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17932 }
17933 return resultobj;
17934 fail:
17935 return NULL;
17936 }
17937
17938
17939 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17940 PyObject *resultobj = 0;
17941 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17942 PyObject *arg2 = (PyObject *) 0 ;
17943 bool arg3 = (bool) true ;
17944 void *argp1 = 0 ;
17945 int res1 = 0 ;
17946 bool val3 ;
17947 int ecode3 = 0 ;
17948 PyObject * obj0 = 0 ;
17949 PyObject * obj1 = 0 ;
17950 PyObject * obj2 = 0 ;
17951 char * kwnames[] = {
17952 (char *) "self",(char *) "_self",(char *) "incref", NULL
17953 };
17954
17955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17957 if (!SWIG_IsOK(res1)) {
17958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17959 }
17960 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17961 arg2 = obj1;
17962 if (obj2) {
17963 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17964 if (!SWIG_IsOK(ecode3)) {
17965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
17966 }
17967 arg3 = static_cast< bool >(val3);
17968 }
17969 {
17970 PyThreadState* __tstate = wxPyBeginAllowThreads();
17971 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
17972 wxPyEndAllowThreads(__tstate);
17973 if (PyErr_Occurred()) SWIG_fail;
17974 }
17975 resultobj = SWIG_Py_Void();
17976 return resultobj;
17977 fail:
17978 return NULL;
17979 }
17980
17981
17982 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17983 PyObject *obj;
17984 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17985 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
17986 return SWIG_Py_Void();
17987 }
17988
17989 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17990 return SWIG_Python_InitShadowInstance(args);
17991 }
17992
17993 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17994 PyObject *resultobj = 0;
17995 wxEventType result;
17996
17997 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
17998 {
17999 PyThreadState* __tstate = wxPyBeginAllowThreads();
18000 result = (wxEventType)wxNewEventType();
18001 wxPyEndAllowThreads(__tstate);
18002 if (PyErr_Occurred()) SWIG_fail;
18003 }
18004 resultobj = SWIG_From_int(static_cast< int >(result));
18005 return resultobj;
18006 fail:
18007 return NULL;
18008 }
18009
18010
18011 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18012 PyObject *resultobj = 0;
18013 wxEvent *arg1 = (wxEvent *) 0 ;
18014 void *argp1 = 0 ;
18015 int res1 = 0 ;
18016 PyObject *swig_obj[1] ;
18017
18018 if (!args) SWIG_fail;
18019 swig_obj[0] = args;
18020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18021 if (!SWIG_IsOK(res1)) {
18022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18023 }
18024 arg1 = reinterpret_cast< wxEvent * >(argp1);
18025 {
18026 PyThreadState* __tstate = wxPyBeginAllowThreads();
18027 delete arg1;
18028
18029 wxPyEndAllowThreads(__tstate);
18030 if (PyErr_Occurred()) SWIG_fail;
18031 }
18032 resultobj = SWIG_Py_Void();
18033 return resultobj;
18034 fail:
18035 return NULL;
18036 }
18037
18038
18039 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18040 PyObject *resultobj = 0;
18041 wxEvent *arg1 = (wxEvent *) 0 ;
18042 wxEventType arg2 ;
18043 void *argp1 = 0 ;
18044 int res1 = 0 ;
18045 int val2 ;
18046 int ecode2 = 0 ;
18047 PyObject * obj0 = 0 ;
18048 PyObject * obj1 = 0 ;
18049 char * kwnames[] = {
18050 (char *) "self",(char *) "typ", NULL
18051 };
18052
18053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18055 if (!SWIG_IsOK(res1)) {
18056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18057 }
18058 arg1 = reinterpret_cast< wxEvent * >(argp1);
18059 ecode2 = SWIG_AsVal_int(obj1, &val2);
18060 if (!SWIG_IsOK(ecode2)) {
18061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18062 }
18063 arg2 = static_cast< wxEventType >(val2);
18064 {
18065 PyThreadState* __tstate = wxPyBeginAllowThreads();
18066 (arg1)->SetEventType(arg2);
18067 wxPyEndAllowThreads(__tstate);
18068 if (PyErr_Occurred()) SWIG_fail;
18069 }
18070 resultobj = SWIG_Py_Void();
18071 return resultobj;
18072 fail:
18073 return NULL;
18074 }
18075
18076
18077 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18078 PyObject *resultobj = 0;
18079 wxEvent *arg1 = (wxEvent *) 0 ;
18080 wxEventType result;
18081 void *argp1 = 0 ;
18082 int res1 = 0 ;
18083 PyObject *swig_obj[1] ;
18084
18085 if (!args) SWIG_fail;
18086 swig_obj[0] = args;
18087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18088 if (!SWIG_IsOK(res1)) {
18089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18090 }
18091 arg1 = reinterpret_cast< wxEvent * >(argp1);
18092 {
18093 PyThreadState* __tstate = wxPyBeginAllowThreads();
18094 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18095 wxPyEndAllowThreads(__tstate);
18096 if (PyErr_Occurred()) SWIG_fail;
18097 }
18098 resultobj = SWIG_From_int(static_cast< int >(result));
18099 return resultobj;
18100 fail:
18101 return NULL;
18102 }
18103
18104
18105 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18106 PyObject *resultobj = 0;
18107 wxEvent *arg1 = (wxEvent *) 0 ;
18108 wxObject *result = 0 ;
18109 void *argp1 = 0 ;
18110 int res1 = 0 ;
18111 PyObject *swig_obj[1] ;
18112
18113 if (!args) SWIG_fail;
18114 swig_obj[0] = args;
18115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18116 if (!SWIG_IsOK(res1)) {
18117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18118 }
18119 arg1 = reinterpret_cast< wxEvent * >(argp1);
18120 {
18121 PyThreadState* __tstate = wxPyBeginAllowThreads();
18122 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18123 wxPyEndAllowThreads(__tstate);
18124 if (PyErr_Occurred()) SWIG_fail;
18125 }
18126 {
18127 resultobj = wxPyMake_wxObject(result, (bool)0);
18128 }
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18136 PyObject *resultobj = 0;
18137 wxEvent *arg1 = (wxEvent *) 0 ;
18138 wxObject *arg2 = (wxObject *) 0 ;
18139 void *argp1 = 0 ;
18140 int res1 = 0 ;
18141 void *argp2 = 0 ;
18142 int res2 = 0 ;
18143 PyObject * obj0 = 0 ;
18144 PyObject * obj1 = 0 ;
18145 char * kwnames[] = {
18146 (char *) "self",(char *) "obj", NULL
18147 };
18148
18149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18151 if (!SWIG_IsOK(res1)) {
18152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18153 }
18154 arg1 = reinterpret_cast< wxEvent * >(argp1);
18155 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18156 if (!SWIG_IsOK(res2)) {
18157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18158 }
18159 arg2 = reinterpret_cast< wxObject * >(argp2);
18160 {
18161 PyThreadState* __tstate = wxPyBeginAllowThreads();
18162 (arg1)->SetEventObject(arg2);
18163 wxPyEndAllowThreads(__tstate);
18164 if (PyErr_Occurred()) SWIG_fail;
18165 }
18166 resultobj = SWIG_Py_Void();
18167 return resultobj;
18168 fail:
18169 return NULL;
18170 }
18171
18172
18173 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18174 PyObject *resultobj = 0;
18175 wxEvent *arg1 = (wxEvent *) 0 ;
18176 long result;
18177 void *argp1 = 0 ;
18178 int res1 = 0 ;
18179 PyObject *swig_obj[1] ;
18180
18181 if (!args) SWIG_fail;
18182 swig_obj[0] = args;
18183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18184 if (!SWIG_IsOK(res1)) {
18185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18186 }
18187 arg1 = reinterpret_cast< wxEvent * >(argp1);
18188 {
18189 PyThreadState* __tstate = wxPyBeginAllowThreads();
18190 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18191 wxPyEndAllowThreads(__tstate);
18192 if (PyErr_Occurred()) SWIG_fail;
18193 }
18194 resultobj = SWIG_From_long(static_cast< long >(result));
18195 return resultobj;
18196 fail:
18197 return NULL;
18198 }
18199
18200
18201 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18202 PyObject *resultobj = 0;
18203 wxEvent *arg1 = (wxEvent *) 0 ;
18204 long arg2 = (long) 0 ;
18205 void *argp1 = 0 ;
18206 int res1 = 0 ;
18207 long val2 ;
18208 int ecode2 = 0 ;
18209 PyObject * obj0 = 0 ;
18210 PyObject * obj1 = 0 ;
18211 char * kwnames[] = {
18212 (char *) "self",(char *) "ts", NULL
18213 };
18214
18215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18217 if (!SWIG_IsOK(res1)) {
18218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18219 }
18220 arg1 = reinterpret_cast< wxEvent * >(argp1);
18221 if (obj1) {
18222 ecode2 = SWIG_AsVal_long(obj1, &val2);
18223 if (!SWIG_IsOK(ecode2)) {
18224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18225 }
18226 arg2 = static_cast< long >(val2);
18227 }
18228 {
18229 PyThreadState* __tstate = wxPyBeginAllowThreads();
18230 (arg1)->SetTimestamp(arg2);
18231 wxPyEndAllowThreads(__tstate);
18232 if (PyErr_Occurred()) SWIG_fail;
18233 }
18234 resultobj = SWIG_Py_Void();
18235 return resultobj;
18236 fail:
18237 return NULL;
18238 }
18239
18240
18241 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18242 PyObject *resultobj = 0;
18243 wxEvent *arg1 = (wxEvent *) 0 ;
18244 int result;
18245 void *argp1 = 0 ;
18246 int res1 = 0 ;
18247 PyObject *swig_obj[1] ;
18248
18249 if (!args) SWIG_fail;
18250 swig_obj[0] = args;
18251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18252 if (!SWIG_IsOK(res1)) {
18253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18254 }
18255 arg1 = reinterpret_cast< wxEvent * >(argp1);
18256 {
18257 PyThreadState* __tstate = wxPyBeginAllowThreads();
18258 result = (int)((wxEvent const *)arg1)->GetId();
18259 wxPyEndAllowThreads(__tstate);
18260 if (PyErr_Occurred()) SWIG_fail;
18261 }
18262 resultobj = SWIG_From_int(static_cast< int >(result));
18263 return resultobj;
18264 fail:
18265 return NULL;
18266 }
18267
18268
18269 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18270 PyObject *resultobj = 0;
18271 wxEvent *arg1 = (wxEvent *) 0 ;
18272 int arg2 ;
18273 void *argp1 = 0 ;
18274 int res1 = 0 ;
18275 int val2 ;
18276 int ecode2 = 0 ;
18277 PyObject * obj0 = 0 ;
18278 PyObject * obj1 = 0 ;
18279 char * kwnames[] = {
18280 (char *) "self",(char *) "Id", NULL
18281 };
18282
18283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18285 if (!SWIG_IsOK(res1)) {
18286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18287 }
18288 arg1 = reinterpret_cast< wxEvent * >(argp1);
18289 ecode2 = SWIG_AsVal_int(obj1, &val2);
18290 if (!SWIG_IsOK(ecode2)) {
18291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18292 }
18293 arg2 = static_cast< int >(val2);
18294 {
18295 PyThreadState* __tstate = wxPyBeginAllowThreads();
18296 (arg1)->SetId(arg2);
18297 wxPyEndAllowThreads(__tstate);
18298 if (PyErr_Occurred()) SWIG_fail;
18299 }
18300 resultobj = SWIG_Py_Void();
18301 return resultobj;
18302 fail:
18303 return NULL;
18304 }
18305
18306
18307 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18308 PyObject *resultobj = 0;
18309 wxEvent *arg1 = (wxEvent *) 0 ;
18310 bool result;
18311 void *argp1 = 0 ;
18312 int res1 = 0 ;
18313 PyObject *swig_obj[1] ;
18314
18315 if (!args) SWIG_fail;
18316 swig_obj[0] = args;
18317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18318 if (!SWIG_IsOK(res1)) {
18319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18320 }
18321 arg1 = reinterpret_cast< wxEvent * >(argp1);
18322 {
18323 PyThreadState* __tstate = wxPyBeginAllowThreads();
18324 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18325 wxPyEndAllowThreads(__tstate);
18326 if (PyErr_Occurred()) SWIG_fail;
18327 }
18328 {
18329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18330 }
18331 return resultobj;
18332 fail:
18333 return NULL;
18334 }
18335
18336
18337 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18338 PyObject *resultobj = 0;
18339 wxEvent *arg1 = (wxEvent *) 0 ;
18340 bool arg2 = (bool) true ;
18341 void *argp1 = 0 ;
18342 int res1 = 0 ;
18343 bool val2 ;
18344 int ecode2 = 0 ;
18345 PyObject * obj0 = 0 ;
18346 PyObject * obj1 = 0 ;
18347 char * kwnames[] = {
18348 (char *) "self",(char *) "skip", NULL
18349 };
18350
18351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18353 if (!SWIG_IsOK(res1)) {
18354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18355 }
18356 arg1 = reinterpret_cast< wxEvent * >(argp1);
18357 if (obj1) {
18358 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18359 if (!SWIG_IsOK(ecode2)) {
18360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18361 }
18362 arg2 = static_cast< bool >(val2);
18363 }
18364 {
18365 PyThreadState* __tstate = wxPyBeginAllowThreads();
18366 (arg1)->Skip(arg2);
18367 wxPyEndAllowThreads(__tstate);
18368 if (PyErr_Occurred()) SWIG_fail;
18369 }
18370 resultobj = SWIG_Py_Void();
18371 return resultobj;
18372 fail:
18373 return NULL;
18374 }
18375
18376
18377 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18378 PyObject *resultobj = 0;
18379 wxEvent *arg1 = (wxEvent *) 0 ;
18380 bool result;
18381 void *argp1 = 0 ;
18382 int res1 = 0 ;
18383 PyObject *swig_obj[1] ;
18384
18385 if (!args) SWIG_fail;
18386 swig_obj[0] = args;
18387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18388 if (!SWIG_IsOK(res1)) {
18389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18390 }
18391 arg1 = reinterpret_cast< wxEvent * >(argp1);
18392 {
18393 PyThreadState* __tstate = wxPyBeginAllowThreads();
18394 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18395 wxPyEndAllowThreads(__tstate);
18396 if (PyErr_Occurred()) SWIG_fail;
18397 }
18398 {
18399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18400 }
18401 return resultobj;
18402 fail:
18403 return NULL;
18404 }
18405
18406
18407 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18408 PyObject *resultobj = 0;
18409 wxEvent *arg1 = (wxEvent *) 0 ;
18410 bool result;
18411 void *argp1 = 0 ;
18412 int res1 = 0 ;
18413 PyObject *swig_obj[1] ;
18414
18415 if (!args) SWIG_fail;
18416 swig_obj[0] = args;
18417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18418 if (!SWIG_IsOK(res1)) {
18419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18420 }
18421 arg1 = reinterpret_cast< wxEvent * >(argp1);
18422 {
18423 PyThreadState* __tstate = wxPyBeginAllowThreads();
18424 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18425 wxPyEndAllowThreads(__tstate);
18426 if (PyErr_Occurred()) SWIG_fail;
18427 }
18428 {
18429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18430 }
18431 return resultobj;
18432 fail:
18433 return NULL;
18434 }
18435
18436
18437 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18438 PyObject *resultobj = 0;
18439 wxEvent *arg1 = (wxEvent *) 0 ;
18440 int result;
18441 void *argp1 = 0 ;
18442 int res1 = 0 ;
18443 PyObject *swig_obj[1] ;
18444
18445 if (!args) SWIG_fail;
18446 swig_obj[0] = args;
18447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18448 if (!SWIG_IsOK(res1)) {
18449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18450 }
18451 arg1 = reinterpret_cast< wxEvent * >(argp1);
18452 {
18453 PyThreadState* __tstate = wxPyBeginAllowThreads();
18454 result = (int)(arg1)->StopPropagation();
18455 wxPyEndAllowThreads(__tstate);
18456 if (PyErr_Occurred()) SWIG_fail;
18457 }
18458 resultobj = SWIG_From_int(static_cast< int >(result));
18459 return resultobj;
18460 fail:
18461 return NULL;
18462 }
18463
18464
18465 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18466 PyObject *resultobj = 0;
18467 wxEvent *arg1 = (wxEvent *) 0 ;
18468 int arg2 ;
18469 void *argp1 = 0 ;
18470 int res1 = 0 ;
18471 int val2 ;
18472 int ecode2 = 0 ;
18473 PyObject * obj0 = 0 ;
18474 PyObject * obj1 = 0 ;
18475 char * kwnames[] = {
18476 (char *) "self",(char *) "propagationLevel", NULL
18477 };
18478
18479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18481 if (!SWIG_IsOK(res1)) {
18482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18483 }
18484 arg1 = reinterpret_cast< wxEvent * >(argp1);
18485 ecode2 = SWIG_AsVal_int(obj1, &val2);
18486 if (!SWIG_IsOK(ecode2)) {
18487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18488 }
18489 arg2 = static_cast< int >(val2);
18490 {
18491 PyThreadState* __tstate = wxPyBeginAllowThreads();
18492 (arg1)->ResumePropagation(arg2);
18493 wxPyEndAllowThreads(__tstate);
18494 if (PyErr_Occurred()) SWIG_fail;
18495 }
18496 resultobj = SWIG_Py_Void();
18497 return resultobj;
18498 fail:
18499 return NULL;
18500 }
18501
18502
18503 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18504 PyObject *resultobj = 0;
18505 wxEvent *arg1 = (wxEvent *) 0 ;
18506 wxEvent *result = 0 ;
18507 void *argp1 = 0 ;
18508 int res1 = 0 ;
18509 PyObject *swig_obj[1] ;
18510
18511 if (!args) SWIG_fail;
18512 swig_obj[0] = args;
18513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18514 if (!SWIG_IsOK(res1)) {
18515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18516 }
18517 arg1 = reinterpret_cast< wxEvent * >(argp1);
18518 {
18519 PyThreadState* __tstate = wxPyBeginAllowThreads();
18520 result = (wxEvent *)(arg1)->Clone();
18521 wxPyEndAllowThreads(__tstate);
18522 if (PyErr_Occurred()) SWIG_fail;
18523 }
18524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18525 return resultobj;
18526 fail:
18527 return NULL;
18528 }
18529
18530
18531 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18532 PyObject *obj;
18533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18534 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18535 return SWIG_Py_Void();
18536 }
18537
18538 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18539 PyObject *resultobj = 0;
18540 wxEvent *arg1 = 0 ;
18541 wxPropagationDisabler *result = 0 ;
18542 void *argp1 = 0 ;
18543 int res1 = 0 ;
18544 PyObject * obj0 = 0 ;
18545 char * kwnames[] = {
18546 (char *) "event", NULL
18547 };
18548
18549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18550 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18551 if (!SWIG_IsOK(res1)) {
18552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18553 }
18554 if (!argp1) {
18555 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18556 }
18557 arg1 = reinterpret_cast< wxEvent * >(argp1);
18558 {
18559 PyThreadState* __tstate = wxPyBeginAllowThreads();
18560 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18561 wxPyEndAllowThreads(__tstate);
18562 if (PyErr_Occurred()) SWIG_fail;
18563 }
18564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18565 return resultobj;
18566 fail:
18567 return NULL;
18568 }
18569
18570
18571 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18572 PyObject *resultobj = 0;
18573 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18574 void *argp1 = 0 ;
18575 int res1 = 0 ;
18576 PyObject *swig_obj[1] ;
18577
18578 if (!args) SWIG_fail;
18579 swig_obj[0] = args;
18580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18581 if (!SWIG_IsOK(res1)) {
18582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18583 }
18584 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18585 {
18586 PyThreadState* __tstate = wxPyBeginAllowThreads();
18587 delete arg1;
18588
18589 wxPyEndAllowThreads(__tstate);
18590 if (PyErr_Occurred()) SWIG_fail;
18591 }
18592 resultobj = SWIG_Py_Void();
18593 return resultobj;
18594 fail:
18595 return NULL;
18596 }
18597
18598
18599 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18600 PyObject *obj;
18601 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18602 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18603 return SWIG_Py_Void();
18604 }
18605
18606 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18607 return SWIG_Python_InitShadowInstance(args);
18608 }
18609
18610 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18611 PyObject *resultobj = 0;
18612 wxEvent *arg1 = 0 ;
18613 wxPropagateOnce *result = 0 ;
18614 void *argp1 = 0 ;
18615 int res1 = 0 ;
18616 PyObject * obj0 = 0 ;
18617 char * kwnames[] = {
18618 (char *) "event", NULL
18619 };
18620
18621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18622 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18623 if (!SWIG_IsOK(res1)) {
18624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18625 }
18626 if (!argp1) {
18627 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18628 }
18629 arg1 = reinterpret_cast< wxEvent * >(argp1);
18630 {
18631 PyThreadState* __tstate = wxPyBeginAllowThreads();
18632 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18633 wxPyEndAllowThreads(__tstate);
18634 if (PyErr_Occurred()) SWIG_fail;
18635 }
18636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18637 return resultobj;
18638 fail:
18639 return NULL;
18640 }
18641
18642
18643 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18644 PyObject *resultobj = 0;
18645 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18646 void *argp1 = 0 ;
18647 int res1 = 0 ;
18648 PyObject *swig_obj[1] ;
18649
18650 if (!args) SWIG_fail;
18651 swig_obj[0] = args;
18652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18653 if (!SWIG_IsOK(res1)) {
18654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18655 }
18656 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18657 {
18658 PyThreadState* __tstate = wxPyBeginAllowThreads();
18659 delete arg1;
18660
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 resultobj = SWIG_Py_Void();
18665 return resultobj;
18666 fail:
18667 return NULL;
18668 }
18669
18670
18671 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18672 PyObject *obj;
18673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18674 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18675 return SWIG_Py_Void();
18676 }
18677
18678 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18679 return SWIG_Python_InitShadowInstance(args);
18680 }
18681
18682 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18683 PyObject *resultobj = 0;
18684 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18685 int arg2 = (int) 0 ;
18686 wxCommandEvent *result = 0 ;
18687 int val1 ;
18688 int ecode1 = 0 ;
18689 int val2 ;
18690 int ecode2 = 0 ;
18691 PyObject * obj0 = 0 ;
18692 PyObject * obj1 = 0 ;
18693 char * kwnames[] = {
18694 (char *) "commandType",(char *) "winid", NULL
18695 };
18696
18697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18698 if (obj0) {
18699 ecode1 = SWIG_AsVal_int(obj0, &val1);
18700 if (!SWIG_IsOK(ecode1)) {
18701 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18702 }
18703 arg1 = static_cast< wxEventType >(val1);
18704 }
18705 if (obj1) {
18706 ecode2 = SWIG_AsVal_int(obj1, &val2);
18707 if (!SWIG_IsOK(ecode2)) {
18708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18709 }
18710 arg2 = static_cast< int >(val2);
18711 }
18712 {
18713 PyThreadState* __tstate = wxPyBeginAllowThreads();
18714 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18715 wxPyEndAllowThreads(__tstate);
18716 if (PyErr_Occurred()) SWIG_fail;
18717 }
18718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18719 return resultobj;
18720 fail:
18721 return NULL;
18722 }
18723
18724
18725 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18726 PyObject *resultobj = 0;
18727 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18728 int result;
18729 void *argp1 = 0 ;
18730 int res1 = 0 ;
18731 PyObject *swig_obj[1] ;
18732
18733 if (!args) SWIG_fail;
18734 swig_obj[0] = args;
18735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18736 if (!SWIG_IsOK(res1)) {
18737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18738 }
18739 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18740 {
18741 PyThreadState* __tstate = wxPyBeginAllowThreads();
18742 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18743 wxPyEndAllowThreads(__tstate);
18744 if (PyErr_Occurred()) SWIG_fail;
18745 }
18746 resultobj = SWIG_From_int(static_cast< int >(result));
18747 return resultobj;
18748 fail:
18749 return NULL;
18750 }
18751
18752
18753 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18754 PyObject *resultobj = 0;
18755 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18756 wxString *arg2 = 0 ;
18757 void *argp1 = 0 ;
18758 int res1 = 0 ;
18759 bool temp2 = false ;
18760 PyObject * obj0 = 0 ;
18761 PyObject * obj1 = 0 ;
18762 char * kwnames[] = {
18763 (char *) "self",(char *) "s", NULL
18764 };
18765
18766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18768 if (!SWIG_IsOK(res1)) {
18769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18770 }
18771 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18772 {
18773 arg2 = wxString_in_helper(obj1);
18774 if (arg2 == NULL) SWIG_fail;
18775 temp2 = true;
18776 }
18777 {
18778 PyThreadState* __tstate = wxPyBeginAllowThreads();
18779 (arg1)->SetString((wxString const &)*arg2);
18780 wxPyEndAllowThreads(__tstate);
18781 if (PyErr_Occurred()) SWIG_fail;
18782 }
18783 resultobj = SWIG_Py_Void();
18784 {
18785 if (temp2)
18786 delete arg2;
18787 }
18788 return resultobj;
18789 fail:
18790 {
18791 if (temp2)
18792 delete arg2;
18793 }
18794 return NULL;
18795 }
18796
18797
18798 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18799 PyObject *resultobj = 0;
18800 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18801 wxString result;
18802 void *argp1 = 0 ;
18803 int res1 = 0 ;
18804 PyObject *swig_obj[1] ;
18805
18806 if (!args) SWIG_fail;
18807 swig_obj[0] = args;
18808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18809 if (!SWIG_IsOK(res1)) {
18810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18811 }
18812 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18813 {
18814 PyThreadState* __tstate = wxPyBeginAllowThreads();
18815 result = ((wxCommandEvent const *)arg1)->GetString();
18816 wxPyEndAllowThreads(__tstate);
18817 if (PyErr_Occurred()) SWIG_fail;
18818 }
18819 {
18820 #if wxUSE_UNICODE
18821 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18822 #else
18823 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18824 #endif
18825 }
18826 return resultobj;
18827 fail:
18828 return NULL;
18829 }
18830
18831
18832 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18833 PyObject *resultobj = 0;
18834 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18835 bool result;
18836 void *argp1 = 0 ;
18837 int res1 = 0 ;
18838 PyObject *swig_obj[1] ;
18839
18840 if (!args) SWIG_fail;
18841 swig_obj[0] = args;
18842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18843 if (!SWIG_IsOK(res1)) {
18844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18845 }
18846 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18847 {
18848 PyThreadState* __tstate = wxPyBeginAllowThreads();
18849 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18850 wxPyEndAllowThreads(__tstate);
18851 if (PyErr_Occurred()) SWIG_fail;
18852 }
18853 {
18854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18855 }
18856 return resultobj;
18857 fail:
18858 return NULL;
18859 }
18860
18861
18862 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18863 PyObject *resultobj = 0;
18864 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18865 bool result;
18866 void *argp1 = 0 ;
18867 int res1 = 0 ;
18868 PyObject *swig_obj[1] ;
18869
18870 if (!args) SWIG_fail;
18871 swig_obj[0] = args;
18872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18873 if (!SWIG_IsOK(res1)) {
18874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18875 }
18876 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18877 {
18878 PyThreadState* __tstate = wxPyBeginAllowThreads();
18879 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18880 wxPyEndAllowThreads(__tstate);
18881 if (PyErr_Occurred()) SWIG_fail;
18882 }
18883 {
18884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18885 }
18886 return resultobj;
18887 fail:
18888 return NULL;
18889 }
18890
18891
18892 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18893 PyObject *resultobj = 0;
18894 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18895 long arg2 ;
18896 void *argp1 = 0 ;
18897 int res1 = 0 ;
18898 long val2 ;
18899 int ecode2 = 0 ;
18900 PyObject * obj0 = 0 ;
18901 PyObject * obj1 = 0 ;
18902 char * kwnames[] = {
18903 (char *) "self",(char *) "extraLong", NULL
18904 };
18905
18906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18908 if (!SWIG_IsOK(res1)) {
18909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18910 }
18911 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18912 ecode2 = SWIG_AsVal_long(obj1, &val2);
18913 if (!SWIG_IsOK(ecode2)) {
18914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18915 }
18916 arg2 = static_cast< long >(val2);
18917 {
18918 PyThreadState* __tstate = wxPyBeginAllowThreads();
18919 (arg1)->SetExtraLong(arg2);
18920 wxPyEndAllowThreads(__tstate);
18921 if (PyErr_Occurred()) SWIG_fail;
18922 }
18923 resultobj = SWIG_Py_Void();
18924 return resultobj;
18925 fail:
18926 return NULL;
18927 }
18928
18929
18930 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18931 PyObject *resultobj = 0;
18932 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18933 long result;
18934 void *argp1 = 0 ;
18935 int res1 = 0 ;
18936 PyObject *swig_obj[1] ;
18937
18938 if (!args) SWIG_fail;
18939 swig_obj[0] = args;
18940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18941 if (!SWIG_IsOK(res1)) {
18942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18943 }
18944 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18945 {
18946 PyThreadState* __tstate = wxPyBeginAllowThreads();
18947 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
18948 wxPyEndAllowThreads(__tstate);
18949 if (PyErr_Occurred()) SWIG_fail;
18950 }
18951 resultobj = SWIG_From_long(static_cast< long >(result));
18952 return resultobj;
18953 fail:
18954 return NULL;
18955 }
18956
18957
18958 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18959 PyObject *resultobj = 0;
18960 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18961 int arg2 ;
18962 void *argp1 = 0 ;
18963 int res1 = 0 ;
18964 int val2 ;
18965 int ecode2 = 0 ;
18966 PyObject * obj0 = 0 ;
18967 PyObject * obj1 = 0 ;
18968 char * kwnames[] = {
18969 (char *) "self",(char *) "i", NULL
18970 };
18971
18972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
18973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18974 if (!SWIG_IsOK(res1)) {
18975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18976 }
18977 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18978 ecode2 = SWIG_AsVal_int(obj1, &val2);
18979 if (!SWIG_IsOK(ecode2)) {
18980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
18981 }
18982 arg2 = static_cast< int >(val2);
18983 {
18984 PyThreadState* __tstate = wxPyBeginAllowThreads();
18985 (arg1)->SetInt(arg2);
18986 wxPyEndAllowThreads(__tstate);
18987 if (PyErr_Occurred()) SWIG_fail;
18988 }
18989 resultobj = SWIG_Py_Void();
18990 return resultobj;
18991 fail:
18992 return NULL;
18993 }
18994
18995
18996 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18997 PyObject *resultobj = 0;
18998 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18999 long result;
19000 void *argp1 = 0 ;
19001 int res1 = 0 ;
19002 PyObject *swig_obj[1] ;
19003
19004 if (!args) SWIG_fail;
19005 swig_obj[0] = args;
19006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19007 if (!SWIG_IsOK(res1)) {
19008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19009 }
19010 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19011 {
19012 PyThreadState* __tstate = wxPyBeginAllowThreads();
19013 result = (long)((wxCommandEvent const *)arg1)->GetInt();
19014 wxPyEndAllowThreads(__tstate);
19015 if (PyErr_Occurred()) SWIG_fail;
19016 }
19017 resultobj = SWIG_From_long(static_cast< long >(result));
19018 return resultobj;
19019 fail:
19020 return NULL;
19021 }
19022
19023
19024 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19025 PyObject *resultobj = 0;
19026 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19027 PyObject *result = 0 ;
19028 void *argp1 = 0 ;
19029 int res1 = 0 ;
19030 PyObject *swig_obj[1] ;
19031
19032 if (!args) SWIG_fail;
19033 swig_obj[0] = args;
19034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19035 if (!SWIG_IsOK(res1)) {
19036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19037 }
19038 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19039 {
19040 PyThreadState* __tstate = wxPyBeginAllowThreads();
19041 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19042 wxPyEndAllowThreads(__tstate);
19043 if (PyErr_Occurred()) SWIG_fail;
19044 }
19045 resultobj = result;
19046 return resultobj;
19047 fail:
19048 return NULL;
19049 }
19050
19051
19052 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19053 PyObject *resultobj = 0;
19054 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19055 PyObject *arg2 = (PyObject *) 0 ;
19056 void *argp1 = 0 ;
19057 int res1 = 0 ;
19058 PyObject * obj0 = 0 ;
19059 PyObject * obj1 = 0 ;
19060 char * kwnames[] = {
19061 (char *) "self",(char *) "clientData", NULL
19062 };
19063
19064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",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_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19068 }
19069 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19070 arg2 = obj1;
19071 {
19072 PyThreadState* __tstate = wxPyBeginAllowThreads();
19073 wxCommandEvent_SetClientData(arg1,arg2);
19074 wxPyEndAllowThreads(__tstate);
19075 if (PyErr_Occurred()) SWIG_fail;
19076 }
19077 resultobj = SWIG_Py_Void();
19078 return resultobj;
19079 fail:
19080 return NULL;
19081 }
19082
19083
19084 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19085 PyObject *resultobj = 0;
19086 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19087 wxEvent *result = 0 ;
19088 void *argp1 = 0 ;
19089 int res1 = 0 ;
19090 PyObject *swig_obj[1] ;
19091
19092 if (!args) SWIG_fail;
19093 swig_obj[0] = args;
19094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19095 if (!SWIG_IsOK(res1)) {
19096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19097 }
19098 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19099 {
19100 PyThreadState* __tstate = wxPyBeginAllowThreads();
19101 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19102 wxPyEndAllowThreads(__tstate);
19103 if (PyErr_Occurred()) SWIG_fail;
19104 }
19105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19106 return resultobj;
19107 fail:
19108 return NULL;
19109 }
19110
19111
19112 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19113 PyObject *obj;
19114 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19115 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19116 return SWIG_Py_Void();
19117 }
19118
19119 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19120 return SWIG_Python_InitShadowInstance(args);
19121 }
19122
19123 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19124 PyObject *resultobj = 0;
19125 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19126 int arg2 = (int) 0 ;
19127 wxNotifyEvent *result = 0 ;
19128 int val1 ;
19129 int ecode1 = 0 ;
19130 int val2 ;
19131 int ecode2 = 0 ;
19132 PyObject * obj0 = 0 ;
19133 PyObject * obj1 = 0 ;
19134 char * kwnames[] = {
19135 (char *) "commandType",(char *) "winid", NULL
19136 };
19137
19138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19139 if (obj0) {
19140 ecode1 = SWIG_AsVal_int(obj0, &val1);
19141 if (!SWIG_IsOK(ecode1)) {
19142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19143 }
19144 arg1 = static_cast< wxEventType >(val1);
19145 }
19146 if (obj1) {
19147 ecode2 = SWIG_AsVal_int(obj1, &val2);
19148 if (!SWIG_IsOK(ecode2)) {
19149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19150 }
19151 arg2 = static_cast< int >(val2);
19152 }
19153 {
19154 PyThreadState* __tstate = wxPyBeginAllowThreads();
19155 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19156 wxPyEndAllowThreads(__tstate);
19157 if (PyErr_Occurred()) SWIG_fail;
19158 }
19159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19167 PyObject *resultobj = 0;
19168 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19169 void *argp1 = 0 ;
19170 int res1 = 0 ;
19171 PyObject *swig_obj[1] ;
19172
19173 if (!args) SWIG_fail;
19174 swig_obj[0] = args;
19175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19176 if (!SWIG_IsOK(res1)) {
19177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19178 }
19179 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19180 {
19181 PyThreadState* __tstate = wxPyBeginAllowThreads();
19182 (arg1)->Veto();
19183 wxPyEndAllowThreads(__tstate);
19184 if (PyErr_Occurred()) SWIG_fail;
19185 }
19186 resultobj = SWIG_Py_Void();
19187 return resultobj;
19188 fail:
19189 return NULL;
19190 }
19191
19192
19193 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19194 PyObject *resultobj = 0;
19195 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19196 void *argp1 = 0 ;
19197 int res1 = 0 ;
19198 PyObject *swig_obj[1] ;
19199
19200 if (!args) SWIG_fail;
19201 swig_obj[0] = args;
19202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19203 if (!SWIG_IsOK(res1)) {
19204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19205 }
19206 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19207 {
19208 PyThreadState* __tstate = wxPyBeginAllowThreads();
19209 (arg1)->Allow();
19210 wxPyEndAllowThreads(__tstate);
19211 if (PyErr_Occurred()) SWIG_fail;
19212 }
19213 resultobj = SWIG_Py_Void();
19214 return resultobj;
19215 fail:
19216 return NULL;
19217 }
19218
19219
19220 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19221 PyObject *resultobj = 0;
19222 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19223 bool result;
19224 void *argp1 = 0 ;
19225 int res1 = 0 ;
19226 PyObject *swig_obj[1] ;
19227
19228 if (!args) SWIG_fail;
19229 swig_obj[0] = args;
19230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19231 if (!SWIG_IsOK(res1)) {
19232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19233 }
19234 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19235 {
19236 PyThreadState* __tstate = wxPyBeginAllowThreads();
19237 result = (bool)(arg1)->IsAllowed();
19238 wxPyEndAllowThreads(__tstate);
19239 if (PyErr_Occurred()) SWIG_fail;
19240 }
19241 {
19242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19243 }
19244 return resultobj;
19245 fail:
19246 return NULL;
19247 }
19248
19249
19250 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19251 PyObject *obj;
19252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19253 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19254 return SWIG_Py_Void();
19255 }
19256
19257 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19258 return SWIG_Python_InitShadowInstance(args);
19259 }
19260
19261 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19262 PyObject *resultobj = 0;
19263 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19264 int arg2 = (int) 0 ;
19265 int arg3 = (int) 0 ;
19266 int arg4 = (int) 0 ;
19267 wxScrollEvent *result = 0 ;
19268 int val1 ;
19269 int ecode1 = 0 ;
19270 int val2 ;
19271 int ecode2 = 0 ;
19272 int val3 ;
19273 int ecode3 = 0 ;
19274 int val4 ;
19275 int ecode4 = 0 ;
19276 PyObject * obj0 = 0 ;
19277 PyObject * obj1 = 0 ;
19278 PyObject * obj2 = 0 ;
19279 PyObject * obj3 = 0 ;
19280 char * kwnames[] = {
19281 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19282 };
19283
19284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19285 if (obj0) {
19286 ecode1 = SWIG_AsVal_int(obj0, &val1);
19287 if (!SWIG_IsOK(ecode1)) {
19288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19289 }
19290 arg1 = static_cast< wxEventType >(val1);
19291 }
19292 if (obj1) {
19293 ecode2 = SWIG_AsVal_int(obj1, &val2);
19294 if (!SWIG_IsOK(ecode2)) {
19295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19296 }
19297 arg2 = static_cast< int >(val2);
19298 }
19299 if (obj2) {
19300 ecode3 = SWIG_AsVal_int(obj2, &val3);
19301 if (!SWIG_IsOK(ecode3)) {
19302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19303 }
19304 arg3 = static_cast< int >(val3);
19305 }
19306 if (obj3) {
19307 ecode4 = SWIG_AsVal_int(obj3, &val4);
19308 if (!SWIG_IsOK(ecode4)) {
19309 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19310 }
19311 arg4 = static_cast< int >(val4);
19312 }
19313 {
19314 PyThreadState* __tstate = wxPyBeginAllowThreads();
19315 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19316 wxPyEndAllowThreads(__tstate);
19317 if (PyErr_Occurred()) SWIG_fail;
19318 }
19319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19320 return resultobj;
19321 fail:
19322 return NULL;
19323 }
19324
19325
19326 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19327 PyObject *resultobj = 0;
19328 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19329 int result;
19330 void *argp1 = 0 ;
19331 int res1 = 0 ;
19332 PyObject *swig_obj[1] ;
19333
19334 if (!args) SWIG_fail;
19335 swig_obj[0] = args;
19336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19337 if (!SWIG_IsOK(res1)) {
19338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19339 }
19340 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19341 {
19342 PyThreadState* __tstate = wxPyBeginAllowThreads();
19343 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19344 wxPyEndAllowThreads(__tstate);
19345 if (PyErr_Occurred()) SWIG_fail;
19346 }
19347 resultobj = SWIG_From_int(static_cast< int >(result));
19348 return resultobj;
19349 fail:
19350 return NULL;
19351 }
19352
19353
19354 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19355 PyObject *resultobj = 0;
19356 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19357 int result;
19358 void *argp1 = 0 ;
19359 int res1 = 0 ;
19360 PyObject *swig_obj[1] ;
19361
19362 if (!args) SWIG_fail;
19363 swig_obj[0] = args;
19364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19365 if (!SWIG_IsOK(res1)) {
19366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19367 }
19368 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19369 {
19370 PyThreadState* __tstate = wxPyBeginAllowThreads();
19371 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19372 wxPyEndAllowThreads(__tstate);
19373 if (PyErr_Occurred()) SWIG_fail;
19374 }
19375 resultobj = SWIG_From_int(static_cast< int >(result));
19376 return resultobj;
19377 fail:
19378 return NULL;
19379 }
19380
19381
19382 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19383 PyObject *resultobj = 0;
19384 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19385 int arg2 ;
19386 void *argp1 = 0 ;
19387 int res1 = 0 ;
19388 int val2 ;
19389 int ecode2 = 0 ;
19390 PyObject * obj0 = 0 ;
19391 PyObject * obj1 = 0 ;
19392 char * kwnames[] = {
19393 (char *) "self",(char *) "orient", NULL
19394 };
19395
19396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19398 if (!SWIG_IsOK(res1)) {
19399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19400 }
19401 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19402 ecode2 = SWIG_AsVal_int(obj1, &val2);
19403 if (!SWIG_IsOK(ecode2)) {
19404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19405 }
19406 arg2 = static_cast< int >(val2);
19407 {
19408 PyThreadState* __tstate = wxPyBeginAllowThreads();
19409 (arg1)->SetOrientation(arg2);
19410 wxPyEndAllowThreads(__tstate);
19411 if (PyErr_Occurred()) SWIG_fail;
19412 }
19413 resultobj = SWIG_Py_Void();
19414 return resultobj;
19415 fail:
19416 return NULL;
19417 }
19418
19419
19420 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19421 PyObject *resultobj = 0;
19422 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19423 int arg2 ;
19424 void *argp1 = 0 ;
19425 int res1 = 0 ;
19426 int val2 ;
19427 int ecode2 = 0 ;
19428 PyObject * obj0 = 0 ;
19429 PyObject * obj1 = 0 ;
19430 char * kwnames[] = {
19431 (char *) "self",(char *) "pos", NULL
19432 };
19433
19434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19436 if (!SWIG_IsOK(res1)) {
19437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19438 }
19439 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19440 ecode2 = SWIG_AsVal_int(obj1, &val2);
19441 if (!SWIG_IsOK(ecode2)) {
19442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19443 }
19444 arg2 = static_cast< int >(val2);
19445 {
19446 PyThreadState* __tstate = wxPyBeginAllowThreads();
19447 (arg1)->SetPosition(arg2);
19448 wxPyEndAllowThreads(__tstate);
19449 if (PyErr_Occurred()) SWIG_fail;
19450 }
19451 resultobj = SWIG_Py_Void();
19452 return resultobj;
19453 fail:
19454 return NULL;
19455 }
19456
19457
19458 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19459 PyObject *obj;
19460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19461 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19462 return SWIG_Py_Void();
19463 }
19464
19465 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19466 return SWIG_Python_InitShadowInstance(args);
19467 }
19468
19469 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19470 PyObject *resultobj = 0;
19471 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19472 int arg2 = (int) 0 ;
19473 int arg3 = (int) 0 ;
19474 wxScrollWinEvent *result = 0 ;
19475 int val1 ;
19476 int ecode1 = 0 ;
19477 int val2 ;
19478 int ecode2 = 0 ;
19479 int val3 ;
19480 int ecode3 = 0 ;
19481 PyObject * obj0 = 0 ;
19482 PyObject * obj1 = 0 ;
19483 PyObject * obj2 = 0 ;
19484 char * kwnames[] = {
19485 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19486 };
19487
19488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19489 if (obj0) {
19490 ecode1 = SWIG_AsVal_int(obj0, &val1);
19491 if (!SWIG_IsOK(ecode1)) {
19492 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19493 }
19494 arg1 = static_cast< wxEventType >(val1);
19495 }
19496 if (obj1) {
19497 ecode2 = SWIG_AsVal_int(obj1, &val2);
19498 if (!SWIG_IsOK(ecode2)) {
19499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19500 }
19501 arg2 = static_cast< int >(val2);
19502 }
19503 if (obj2) {
19504 ecode3 = SWIG_AsVal_int(obj2, &val3);
19505 if (!SWIG_IsOK(ecode3)) {
19506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19507 }
19508 arg3 = static_cast< int >(val3);
19509 }
19510 {
19511 PyThreadState* __tstate = wxPyBeginAllowThreads();
19512 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19513 wxPyEndAllowThreads(__tstate);
19514 if (PyErr_Occurred()) SWIG_fail;
19515 }
19516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19517 return resultobj;
19518 fail:
19519 return NULL;
19520 }
19521
19522
19523 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19524 PyObject *resultobj = 0;
19525 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19526 int result;
19527 void *argp1 = 0 ;
19528 int res1 = 0 ;
19529 PyObject *swig_obj[1] ;
19530
19531 if (!args) SWIG_fail;
19532 swig_obj[0] = args;
19533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19534 if (!SWIG_IsOK(res1)) {
19535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19536 }
19537 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19538 {
19539 PyThreadState* __tstate = wxPyBeginAllowThreads();
19540 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19541 wxPyEndAllowThreads(__tstate);
19542 if (PyErr_Occurred()) SWIG_fail;
19543 }
19544 resultobj = SWIG_From_int(static_cast< int >(result));
19545 return resultobj;
19546 fail:
19547 return NULL;
19548 }
19549
19550
19551 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19552 PyObject *resultobj = 0;
19553 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19554 int result;
19555 void *argp1 = 0 ;
19556 int res1 = 0 ;
19557 PyObject *swig_obj[1] ;
19558
19559 if (!args) SWIG_fail;
19560 swig_obj[0] = args;
19561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19562 if (!SWIG_IsOK(res1)) {
19563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19564 }
19565 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19566 {
19567 PyThreadState* __tstate = wxPyBeginAllowThreads();
19568 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19569 wxPyEndAllowThreads(__tstate);
19570 if (PyErr_Occurred()) SWIG_fail;
19571 }
19572 resultobj = SWIG_From_int(static_cast< int >(result));
19573 return resultobj;
19574 fail:
19575 return NULL;
19576 }
19577
19578
19579 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19580 PyObject *resultobj = 0;
19581 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19582 int arg2 ;
19583 void *argp1 = 0 ;
19584 int res1 = 0 ;
19585 int val2 ;
19586 int ecode2 = 0 ;
19587 PyObject * obj0 = 0 ;
19588 PyObject * obj1 = 0 ;
19589 char * kwnames[] = {
19590 (char *) "self",(char *) "orient", NULL
19591 };
19592
19593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19595 if (!SWIG_IsOK(res1)) {
19596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19597 }
19598 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19599 ecode2 = SWIG_AsVal_int(obj1, &val2);
19600 if (!SWIG_IsOK(ecode2)) {
19601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19602 }
19603 arg2 = static_cast< int >(val2);
19604 {
19605 PyThreadState* __tstate = wxPyBeginAllowThreads();
19606 (arg1)->SetOrientation(arg2);
19607 wxPyEndAllowThreads(__tstate);
19608 if (PyErr_Occurred()) SWIG_fail;
19609 }
19610 resultobj = SWIG_Py_Void();
19611 return resultobj;
19612 fail:
19613 return NULL;
19614 }
19615
19616
19617 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19618 PyObject *resultobj = 0;
19619 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19620 int arg2 ;
19621 void *argp1 = 0 ;
19622 int res1 = 0 ;
19623 int val2 ;
19624 int ecode2 = 0 ;
19625 PyObject * obj0 = 0 ;
19626 PyObject * obj1 = 0 ;
19627 char * kwnames[] = {
19628 (char *) "self",(char *) "pos", NULL
19629 };
19630
19631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19633 if (!SWIG_IsOK(res1)) {
19634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19635 }
19636 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19637 ecode2 = SWIG_AsVal_int(obj1, &val2);
19638 if (!SWIG_IsOK(ecode2)) {
19639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19640 }
19641 arg2 = static_cast< int >(val2);
19642 {
19643 PyThreadState* __tstate = wxPyBeginAllowThreads();
19644 (arg1)->SetPosition(arg2);
19645 wxPyEndAllowThreads(__tstate);
19646 if (PyErr_Occurred()) SWIG_fail;
19647 }
19648 resultobj = SWIG_Py_Void();
19649 return resultobj;
19650 fail:
19651 return NULL;
19652 }
19653
19654
19655 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19656 PyObject *obj;
19657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19658 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19659 return SWIG_Py_Void();
19660 }
19661
19662 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19663 return SWIG_Python_InitShadowInstance(args);
19664 }
19665
19666 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19667 PyObject *resultobj = 0;
19668 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19669 wxMouseEvent *result = 0 ;
19670 int val1 ;
19671 int ecode1 = 0 ;
19672 PyObject * obj0 = 0 ;
19673 char * kwnames[] = {
19674 (char *) "mouseType", NULL
19675 };
19676
19677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19678 if (obj0) {
19679 ecode1 = SWIG_AsVal_int(obj0, &val1);
19680 if (!SWIG_IsOK(ecode1)) {
19681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19682 }
19683 arg1 = static_cast< wxEventType >(val1);
19684 }
19685 {
19686 PyThreadState* __tstate = wxPyBeginAllowThreads();
19687 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 {
19692 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19693 }
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19701 PyObject *resultobj = 0;
19702 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19703 bool result;
19704 void *argp1 = 0 ;
19705 int res1 = 0 ;
19706 PyObject *swig_obj[1] ;
19707
19708 if (!args) SWIG_fail;
19709 swig_obj[0] = args;
19710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19711 if (!SWIG_IsOK(res1)) {
19712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19713 }
19714 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 {
19722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19723 }
19724 return resultobj;
19725 fail:
19726 return NULL;
19727 }
19728
19729
19730 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19731 PyObject *resultobj = 0;
19732 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19733 int arg2 = (int) wxMOUSE_BTN_ANY ;
19734 bool result;
19735 void *argp1 = 0 ;
19736 int res1 = 0 ;
19737 int val2 ;
19738 int ecode2 = 0 ;
19739 PyObject * obj0 = 0 ;
19740 PyObject * obj1 = 0 ;
19741 char * kwnames[] = {
19742 (char *) "self",(char *) "but", NULL
19743 };
19744
19745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19747 if (!SWIG_IsOK(res1)) {
19748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19749 }
19750 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19751 if (obj1) {
19752 ecode2 = SWIG_AsVal_int(obj1, &val2);
19753 if (!SWIG_IsOK(ecode2)) {
19754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19755 }
19756 arg2 = static_cast< int >(val2);
19757 }
19758 {
19759 PyThreadState* __tstate = wxPyBeginAllowThreads();
19760 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19761 wxPyEndAllowThreads(__tstate);
19762 if (PyErr_Occurred()) SWIG_fail;
19763 }
19764 {
19765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19766 }
19767 return resultobj;
19768 fail:
19769 return NULL;
19770 }
19771
19772
19773 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19774 PyObject *resultobj = 0;
19775 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19776 int arg2 = (int) wxMOUSE_BTN_ANY ;
19777 bool result;
19778 void *argp1 = 0 ;
19779 int res1 = 0 ;
19780 int val2 ;
19781 int ecode2 = 0 ;
19782 PyObject * obj0 = 0 ;
19783 PyObject * obj1 = 0 ;
19784 char * kwnames[] = {
19785 (char *) "self",(char *) "but", NULL
19786 };
19787
19788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19790 if (!SWIG_IsOK(res1)) {
19791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19792 }
19793 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19794 if (obj1) {
19795 ecode2 = SWIG_AsVal_int(obj1, &val2);
19796 if (!SWIG_IsOK(ecode2)) {
19797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19798 }
19799 arg2 = static_cast< int >(val2);
19800 }
19801 {
19802 PyThreadState* __tstate = wxPyBeginAllowThreads();
19803 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19804 wxPyEndAllowThreads(__tstate);
19805 if (PyErr_Occurred()) SWIG_fail;
19806 }
19807 {
19808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19809 }
19810 return resultobj;
19811 fail:
19812 return NULL;
19813 }
19814
19815
19816 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19817 PyObject *resultobj = 0;
19818 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19819 int arg2 = (int) wxMOUSE_BTN_ANY ;
19820 bool result;
19821 void *argp1 = 0 ;
19822 int res1 = 0 ;
19823 int val2 ;
19824 int ecode2 = 0 ;
19825 PyObject * obj0 = 0 ;
19826 PyObject * obj1 = 0 ;
19827 char * kwnames[] = {
19828 (char *) "self",(char *) "but", NULL
19829 };
19830
19831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19833 if (!SWIG_IsOK(res1)) {
19834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19835 }
19836 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19837 if (obj1) {
19838 ecode2 = SWIG_AsVal_int(obj1, &val2);
19839 if (!SWIG_IsOK(ecode2)) {
19840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19841 }
19842 arg2 = static_cast< int >(val2);
19843 }
19844 {
19845 PyThreadState* __tstate = wxPyBeginAllowThreads();
19846 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19847 wxPyEndAllowThreads(__tstate);
19848 if (PyErr_Occurred()) SWIG_fail;
19849 }
19850 {
19851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19852 }
19853 return resultobj;
19854 fail:
19855 return NULL;
19856 }
19857
19858
19859 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19860 PyObject *resultobj = 0;
19861 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19862 int arg2 ;
19863 bool result;
19864 void *argp1 = 0 ;
19865 int res1 = 0 ;
19866 int val2 ;
19867 int ecode2 = 0 ;
19868 PyObject * obj0 = 0 ;
19869 PyObject * obj1 = 0 ;
19870 char * kwnames[] = {
19871 (char *) "self",(char *) "button", NULL
19872 };
19873
19874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19876 if (!SWIG_IsOK(res1)) {
19877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19878 }
19879 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19880 ecode2 = SWIG_AsVal_int(obj1, &val2);
19881 if (!SWIG_IsOK(ecode2)) {
19882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19883 }
19884 arg2 = static_cast< int >(val2);
19885 {
19886 PyThreadState* __tstate = wxPyBeginAllowThreads();
19887 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19888 wxPyEndAllowThreads(__tstate);
19889 if (PyErr_Occurred()) SWIG_fail;
19890 }
19891 {
19892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19893 }
19894 return resultobj;
19895 fail:
19896 return NULL;
19897 }
19898
19899
19900 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19901 PyObject *resultobj = 0;
19902 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19903 int arg2 ;
19904 bool result;
19905 void *argp1 = 0 ;
19906 int res1 = 0 ;
19907 int val2 ;
19908 int ecode2 = 0 ;
19909 PyObject * obj0 = 0 ;
19910 PyObject * obj1 = 0 ;
19911 char * kwnames[] = {
19912 (char *) "self",(char *) "but", NULL
19913 };
19914
19915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
19916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19917 if (!SWIG_IsOK(res1)) {
19918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19919 }
19920 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19921 ecode2 = SWIG_AsVal_int(obj1, &val2);
19922 if (!SWIG_IsOK(ecode2)) {
19923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
19924 }
19925 arg2 = static_cast< int >(val2);
19926 {
19927 PyThreadState* __tstate = wxPyBeginAllowThreads();
19928 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
19929 wxPyEndAllowThreads(__tstate);
19930 if (PyErr_Occurred()) SWIG_fail;
19931 }
19932 {
19933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19934 }
19935 return resultobj;
19936 fail:
19937 return NULL;
19938 }
19939
19940
19941 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19942 PyObject *resultobj = 0;
19943 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19944 int result;
19945 void *argp1 = 0 ;
19946 int res1 = 0 ;
19947 PyObject *swig_obj[1] ;
19948
19949 if (!args) SWIG_fail;
19950 swig_obj[0] = args;
19951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19952 if (!SWIG_IsOK(res1)) {
19953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19954 }
19955 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19956 {
19957 PyThreadState* __tstate = wxPyBeginAllowThreads();
19958 result = (int)((wxMouseEvent const *)arg1)->GetButton();
19959 wxPyEndAllowThreads(__tstate);
19960 if (PyErr_Occurred()) SWIG_fail;
19961 }
19962 resultobj = SWIG_From_int(static_cast< int >(result));
19963 return resultobj;
19964 fail:
19965 return NULL;
19966 }
19967
19968
19969 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19970 PyObject *resultobj = 0;
19971 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19972 bool result;
19973 void *argp1 = 0 ;
19974 int res1 = 0 ;
19975 PyObject *swig_obj[1] ;
19976
19977 if (!args) SWIG_fail;
19978 swig_obj[0] = args;
19979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19980 if (!SWIG_IsOK(res1)) {
19981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19982 }
19983 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19984 {
19985 PyThreadState* __tstate = wxPyBeginAllowThreads();
19986 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
19987 wxPyEndAllowThreads(__tstate);
19988 if (PyErr_Occurred()) SWIG_fail;
19989 }
19990 {
19991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19992 }
19993 return resultobj;
19994 fail:
19995 return NULL;
19996 }
19997
19998
19999 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20000 PyObject *resultobj = 0;
20001 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20002 bool result;
20003 void *argp1 = 0 ;
20004 int res1 = 0 ;
20005 PyObject *swig_obj[1] ;
20006
20007 if (!args) SWIG_fail;
20008 swig_obj[0] = args;
20009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20010 if (!SWIG_IsOK(res1)) {
20011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20012 }
20013 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20014 {
20015 PyThreadState* __tstate = wxPyBeginAllowThreads();
20016 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20017 wxPyEndAllowThreads(__tstate);
20018 if (PyErr_Occurred()) SWIG_fail;
20019 }
20020 {
20021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20022 }
20023 return resultobj;
20024 fail:
20025 return NULL;
20026 }
20027
20028
20029 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20030 PyObject *resultobj = 0;
20031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20032 bool result;
20033 void *argp1 = 0 ;
20034 int res1 = 0 ;
20035 PyObject *swig_obj[1] ;
20036
20037 if (!args) SWIG_fail;
20038 swig_obj[0] = args;
20039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20040 if (!SWIG_IsOK(res1)) {
20041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20042 }
20043 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20044 {
20045 PyThreadState* __tstate = wxPyBeginAllowThreads();
20046 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20047 wxPyEndAllowThreads(__tstate);
20048 if (PyErr_Occurred()) SWIG_fail;
20049 }
20050 {
20051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20052 }
20053 return resultobj;
20054 fail:
20055 return NULL;
20056 }
20057
20058
20059 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20060 PyObject *resultobj = 0;
20061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20062 bool result;
20063 void *argp1 = 0 ;
20064 int res1 = 0 ;
20065 PyObject *swig_obj[1] ;
20066
20067 if (!args) SWIG_fail;
20068 swig_obj[0] = args;
20069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20070 if (!SWIG_IsOK(res1)) {
20071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20072 }
20073 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20074 {
20075 PyThreadState* __tstate = wxPyBeginAllowThreads();
20076 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20077 wxPyEndAllowThreads(__tstate);
20078 if (PyErr_Occurred()) SWIG_fail;
20079 }
20080 {
20081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20082 }
20083 return resultobj;
20084 fail:
20085 return NULL;
20086 }
20087
20088
20089 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20090 PyObject *resultobj = 0;
20091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20092 bool result;
20093 void *argp1 = 0 ;
20094 int res1 = 0 ;
20095 PyObject *swig_obj[1] ;
20096
20097 if (!args) SWIG_fail;
20098 swig_obj[0] = args;
20099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20100 if (!SWIG_IsOK(res1)) {
20101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20102 }
20103 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20104 {
20105 PyThreadState* __tstate = wxPyBeginAllowThreads();
20106 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20107 wxPyEndAllowThreads(__tstate);
20108 if (PyErr_Occurred()) SWIG_fail;
20109 }
20110 {
20111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20112 }
20113 return resultobj;
20114 fail:
20115 return NULL;
20116 }
20117
20118
20119 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20120 PyObject *resultobj = 0;
20121 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20122 bool result;
20123 void *argp1 = 0 ;
20124 int res1 = 0 ;
20125 PyObject *swig_obj[1] ;
20126
20127 if (!args) SWIG_fail;
20128 swig_obj[0] = args;
20129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20130 if (!SWIG_IsOK(res1)) {
20131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20132 }
20133 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20134 {
20135 PyThreadState* __tstate = wxPyBeginAllowThreads();
20136 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20137 wxPyEndAllowThreads(__tstate);
20138 if (PyErr_Occurred()) SWIG_fail;
20139 }
20140 {
20141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20142 }
20143 return resultobj;
20144 fail:
20145 return NULL;
20146 }
20147
20148
20149 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20150 PyObject *resultobj = 0;
20151 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20152 bool result;
20153 void *argp1 = 0 ;
20154 int res1 = 0 ;
20155 PyObject *swig_obj[1] ;
20156
20157 if (!args) SWIG_fail;
20158 swig_obj[0] = args;
20159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20160 if (!SWIG_IsOK(res1)) {
20161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20162 }
20163 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20164 {
20165 PyThreadState* __tstate = wxPyBeginAllowThreads();
20166 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20167 wxPyEndAllowThreads(__tstate);
20168 if (PyErr_Occurred()) SWIG_fail;
20169 }
20170 {
20171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20172 }
20173 return resultobj;
20174 fail:
20175 return NULL;
20176 }
20177
20178
20179 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20180 PyObject *resultobj = 0;
20181 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20182 bool result;
20183 void *argp1 = 0 ;
20184 int res1 = 0 ;
20185 PyObject *swig_obj[1] ;
20186
20187 if (!args) SWIG_fail;
20188 swig_obj[0] = args;
20189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20190 if (!SWIG_IsOK(res1)) {
20191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20192 }
20193 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20197 wxPyEndAllowThreads(__tstate);
20198 if (PyErr_Occurred()) SWIG_fail;
20199 }
20200 {
20201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20202 }
20203 return resultobj;
20204 fail:
20205 return NULL;
20206 }
20207
20208
20209 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20210 PyObject *resultobj = 0;
20211 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20212 bool result;
20213 void *argp1 = 0 ;
20214 int res1 = 0 ;
20215 PyObject *swig_obj[1] ;
20216
20217 if (!args) SWIG_fail;
20218 swig_obj[0] = args;
20219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20220 if (!SWIG_IsOK(res1)) {
20221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20222 }
20223 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20224 {
20225 PyThreadState* __tstate = wxPyBeginAllowThreads();
20226 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20227 wxPyEndAllowThreads(__tstate);
20228 if (PyErr_Occurred()) SWIG_fail;
20229 }
20230 {
20231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20232 }
20233 return resultobj;
20234 fail:
20235 return NULL;
20236 }
20237
20238
20239 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20240 PyObject *resultobj = 0;
20241 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20242 bool result;
20243 void *argp1 = 0 ;
20244 int res1 = 0 ;
20245 PyObject *swig_obj[1] ;
20246
20247 if (!args) SWIG_fail;
20248 swig_obj[0] = args;
20249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20250 if (!SWIG_IsOK(res1)) {
20251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20252 }
20253 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20254 {
20255 PyThreadState* __tstate = wxPyBeginAllowThreads();
20256 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20257 wxPyEndAllowThreads(__tstate);
20258 if (PyErr_Occurred()) SWIG_fail;
20259 }
20260 {
20261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20262 }
20263 return resultobj;
20264 fail:
20265 return NULL;
20266 }
20267
20268
20269 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20270 PyObject *resultobj = 0;
20271 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20272 bool result;
20273 void *argp1 = 0 ;
20274 int res1 = 0 ;
20275 PyObject *swig_obj[1] ;
20276
20277 if (!args) SWIG_fail;
20278 swig_obj[0] = args;
20279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20280 if (!SWIG_IsOK(res1)) {
20281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20282 }
20283 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20284 {
20285 PyThreadState* __tstate = wxPyBeginAllowThreads();
20286 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20287 wxPyEndAllowThreads(__tstate);
20288 if (PyErr_Occurred()) SWIG_fail;
20289 }
20290 {
20291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20292 }
20293 return resultobj;
20294 fail:
20295 return NULL;
20296 }
20297
20298
20299 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20300 PyObject *resultobj = 0;
20301 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20302 bool result;
20303 void *argp1 = 0 ;
20304 int res1 = 0 ;
20305 PyObject *swig_obj[1] ;
20306
20307 if (!args) SWIG_fail;
20308 swig_obj[0] = args;
20309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20310 if (!SWIG_IsOK(res1)) {
20311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20312 }
20313 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20317 wxPyEndAllowThreads(__tstate);
20318 if (PyErr_Occurred()) SWIG_fail;
20319 }
20320 {
20321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20322 }
20323 return resultobj;
20324 fail:
20325 return NULL;
20326 }
20327
20328
20329 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20330 PyObject *resultobj = 0;
20331 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20332 bool result;
20333 void *argp1 = 0 ;
20334 int res1 = 0 ;
20335 PyObject *swig_obj[1] ;
20336
20337 if (!args) SWIG_fail;
20338 swig_obj[0] = args;
20339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20340 if (!SWIG_IsOK(res1)) {
20341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20342 }
20343 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20344 {
20345 PyThreadState* __tstate = wxPyBeginAllowThreads();
20346 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20347 wxPyEndAllowThreads(__tstate);
20348 if (PyErr_Occurred()) SWIG_fail;
20349 }
20350 {
20351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20352 }
20353 return resultobj;
20354 fail:
20355 return NULL;
20356 }
20357
20358
20359 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20360 PyObject *resultobj = 0;
20361 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20362 bool result;
20363 void *argp1 = 0 ;
20364 int res1 = 0 ;
20365 PyObject *swig_obj[1] ;
20366
20367 if (!args) SWIG_fail;
20368 swig_obj[0] = args;
20369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20370 if (!SWIG_IsOK(res1)) {
20371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20372 }
20373 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20374 {
20375 PyThreadState* __tstate = wxPyBeginAllowThreads();
20376 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20377 wxPyEndAllowThreads(__tstate);
20378 if (PyErr_Occurred()) SWIG_fail;
20379 }
20380 {
20381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20382 }
20383 return resultobj;
20384 fail:
20385 return NULL;
20386 }
20387
20388
20389 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20390 PyObject *resultobj = 0;
20391 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20392 bool result;
20393 void *argp1 = 0 ;
20394 int res1 = 0 ;
20395 PyObject *swig_obj[1] ;
20396
20397 if (!args) SWIG_fail;
20398 swig_obj[0] = args;
20399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20400 if (!SWIG_IsOK(res1)) {
20401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20402 }
20403 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20404 {
20405 PyThreadState* __tstate = wxPyBeginAllowThreads();
20406 result = (bool)(arg1)->LeftIsDown();
20407 wxPyEndAllowThreads(__tstate);
20408 if (PyErr_Occurred()) SWIG_fail;
20409 }
20410 {
20411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20412 }
20413 return resultobj;
20414 fail:
20415 return NULL;
20416 }
20417
20418
20419 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20420 PyObject *resultobj = 0;
20421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20422 bool result;
20423 void *argp1 = 0 ;
20424 int res1 = 0 ;
20425 PyObject *swig_obj[1] ;
20426
20427 if (!args) SWIG_fail;
20428 swig_obj[0] = args;
20429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20430 if (!SWIG_IsOK(res1)) {
20431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20432 }
20433 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20434 {
20435 PyThreadState* __tstate = wxPyBeginAllowThreads();
20436 result = (bool)(arg1)->MiddleIsDown();
20437 wxPyEndAllowThreads(__tstate);
20438 if (PyErr_Occurred()) SWIG_fail;
20439 }
20440 {
20441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20442 }
20443 return resultobj;
20444 fail:
20445 return NULL;
20446 }
20447
20448
20449 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20450 PyObject *resultobj = 0;
20451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20452 bool result;
20453 void *argp1 = 0 ;
20454 int res1 = 0 ;
20455 PyObject *swig_obj[1] ;
20456
20457 if (!args) SWIG_fail;
20458 swig_obj[0] = args;
20459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20460 if (!SWIG_IsOK(res1)) {
20461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20462 }
20463 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20464 {
20465 PyThreadState* __tstate = wxPyBeginAllowThreads();
20466 result = (bool)(arg1)->RightIsDown();
20467 wxPyEndAllowThreads(__tstate);
20468 if (PyErr_Occurred()) SWIG_fail;
20469 }
20470 {
20471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20472 }
20473 return resultobj;
20474 fail:
20475 return NULL;
20476 }
20477
20478
20479 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20480 PyObject *resultobj = 0;
20481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20482 bool result;
20483 void *argp1 = 0 ;
20484 int res1 = 0 ;
20485 PyObject *swig_obj[1] ;
20486
20487 if (!args) SWIG_fail;
20488 swig_obj[0] = args;
20489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20490 if (!SWIG_IsOK(res1)) {
20491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20492 }
20493 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20494 {
20495 PyThreadState* __tstate = wxPyBeginAllowThreads();
20496 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20497 wxPyEndAllowThreads(__tstate);
20498 if (PyErr_Occurred()) SWIG_fail;
20499 }
20500 {
20501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20502 }
20503 return resultobj;
20504 fail:
20505 return NULL;
20506 }
20507
20508
20509 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20510 PyObject *resultobj = 0;
20511 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20512 bool result;
20513 void *argp1 = 0 ;
20514 int res1 = 0 ;
20515 PyObject *swig_obj[1] ;
20516
20517 if (!args) SWIG_fail;
20518 swig_obj[0] = args;
20519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20520 if (!SWIG_IsOK(res1)) {
20521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20522 }
20523 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20524 {
20525 PyThreadState* __tstate = wxPyBeginAllowThreads();
20526 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20527 wxPyEndAllowThreads(__tstate);
20528 if (PyErr_Occurred()) SWIG_fail;
20529 }
20530 {
20531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20532 }
20533 return resultobj;
20534 fail:
20535 return NULL;
20536 }
20537
20538
20539 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20540 PyObject *resultobj = 0;
20541 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20542 bool result;
20543 void *argp1 = 0 ;
20544 int res1 = 0 ;
20545 PyObject *swig_obj[1] ;
20546
20547 if (!args) SWIG_fail;
20548 swig_obj[0] = args;
20549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20550 if (!SWIG_IsOK(res1)) {
20551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20552 }
20553 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20554 {
20555 PyThreadState* __tstate = wxPyBeginAllowThreads();
20556 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20557 wxPyEndAllowThreads(__tstate);
20558 if (PyErr_Occurred()) SWIG_fail;
20559 }
20560 {
20561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20562 }
20563 return resultobj;
20564 fail:
20565 return NULL;
20566 }
20567
20568
20569 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20570 PyObject *resultobj = 0;
20571 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20572 bool result;
20573 void *argp1 = 0 ;
20574 int res1 = 0 ;
20575 PyObject *swig_obj[1] ;
20576
20577 if (!args) SWIG_fail;
20578 swig_obj[0] = args;
20579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20580 if (!SWIG_IsOK(res1)) {
20581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20582 }
20583 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20584 {
20585 PyThreadState* __tstate = wxPyBeginAllowThreads();
20586 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20587 wxPyEndAllowThreads(__tstate);
20588 if (PyErr_Occurred()) SWIG_fail;
20589 }
20590 {
20591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20592 }
20593 return resultobj;
20594 fail:
20595 return NULL;
20596 }
20597
20598
20599 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20600 PyObject *resultobj = 0;
20601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20602 wxPoint result;
20603 void *argp1 = 0 ;
20604 int res1 = 0 ;
20605 PyObject *swig_obj[1] ;
20606
20607 if (!args) SWIG_fail;
20608 swig_obj[0] = args;
20609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20610 if (!SWIG_IsOK(res1)) {
20611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20612 }
20613 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20614 {
20615 PyThreadState* __tstate = wxPyBeginAllowThreads();
20616 result = (arg1)->GetPosition();
20617 wxPyEndAllowThreads(__tstate);
20618 if (PyErr_Occurred()) SWIG_fail;
20619 }
20620 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20621 return resultobj;
20622 fail:
20623 return NULL;
20624 }
20625
20626
20627 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20628 PyObject *resultobj = 0;
20629 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20630 long *arg2 = (long *) 0 ;
20631 long *arg3 = (long *) 0 ;
20632 void *argp1 = 0 ;
20633 int res1 = 0 ;
20634 long temp2 ;
20635 int res2 = SWIG_TMPOBJ ;
20636 long temp3 ;
20637 int res3 = SWIG_TMPOBJ ;
20638 PyObject *swig_obj[1] ;
20639
20640 arg2 = &temp2;
20641 arg3 = &temp3;
20642 if (!args) SWIG_fail;
20643 swig_obj[0] = args;
20644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20645 if (!SWIG_IsOK(res1)) {
20646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20647 }
20648 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20649 {
20650 PyThreadState* __tstate = wxPyBeginAllowThreads();
20651 (arg1)->GetPosition(arg2,arg3);
20652 wxPyEndAllowThreads(__tstate);
20653 if (PyErr_Occurred()) SWIG_fail;
20654 }
20655 resultobj = SWIG_Py_Void();
20656 if (SWIG_IsTmpObj(res2)) {
20657 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20658 } else {
20659 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20660 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20661 }
20662 if (SWIG_IsTmpObj(res3)) {
20663 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20664 } else {
20665 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20666 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20667 }
20668 return resultobj;
20669 fail:
20670 return NULL;
20671 }
20672
20673
20674 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20675 PyObject *resultobj = 0;
20676 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20677 wxDC *arg2 = 0 ;
20678 wxPoint result;
20679 void *argp1 = 0 ;
20680 int res1 = 0 ;
20681 void *argp2 = 0 ;
20682 int res2 = 0 ;
20683 PyObject * obj0 = 0 ;
20684 PyObject * obj1 = 0 ;
20685 char * kwnames[] = {
20686 (char *) "self",(char *) "dc", NULL
20687 };
20688
20689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20691 if (!SWIG_IsOK(res1)) {
20692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20693 }
20694 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20695 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20696 if (!SWIG_IsOK(res2)) {
20697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20698 }
20699 if (!argp2) {
20700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20701 }
20702 arg2 = reinterpret_cast< wxDC * >(argp2);
20703 {
20704 PyThreadState* __tstate = wxPyBeginAllowThreads();
20705 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20706 wxPyEndAllowThreads(__tstate);
20707 if (PyErr_Occurred()) SWIG_fail;
20708 }
20709 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20710 return resultobj;
20711 fail:
20712 return NULL;
20713 }
20714
20715
20716 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20717 PyObject *resultobj = 0;
20718 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20719 int result;
20720 void *argp1 = 0 ;
20721 int res1 = 0 ;
20722 PyObject *swig_obj[1] ;
20723
20724 if (!args) SWIG_fail;
20725 swig_obj[0] = args;
20726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20727 if (!SWIG_IsOK(res1)) {
20728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20729 }
20730 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20731 {
20732 PyThreadState* __tstate = wxPyBeginAllowThreads();
20733 result = (int)((wxMouseEvent const *)arg1)->GetX();
20734 wxPyEndAllowThreads(__tstate);
20735 if (PyErr_Occurred()) SWIG_fail;
20736 }
20737 resultobj = SWIG_From_int(static_cast< int >(result));
20738 return resultobj;
20739 fail:
20740 return NULL;
20741 }
20742
20743
20744 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20745 PyObject *resultobj = 0;
20746 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20747 int result;
20748 void *argp1 = 0 ;
20749 int res1 = 0 ;
20750 PyObject *swig_obj[1] ;
20751
20752 if (!args) SWIG_fail;
20753 swig_obj[0] = args;
20754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20755 if (!SWIG_IsOK(res1)) {
20756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20757 }
20758 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20759 {
20760 PyThreadState* __tstate = wxPyBeginAllowThreads();
20761 result = (int)((wxMouseEvent const *)arg1)->GetY();
20762 wxPyEndAllowThreads(__tstate);
20763 if (PyErr_Occurred()) SWIG_fail;
20764 }
20765 resultobj = SWIG_From_int(static_cast< int >(result));
20766 return resultobj;
20767 fail:
20768 return NULL;
20769 }
20770
20771
20772 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20773 PyObject *resultobj = 0;
20774 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20775 int result;
20776 void *argp1 = 0 ;
20777 int res1 = 0 ;
20778 PyObject *swig_obj[1] ;
20779
20780 if (!args) SWIG_fail;
20781 swig_obj[0] = args;
20782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20783 if (!SWIG_IsOK(res1)) {
20784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20785 }
20786 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20787 {
20788 PyThreadState* __tstate = wxPyBeginAllowThreads();
20789 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20790 wxPyEndAllowThreads(__tstate);
20791 if (PyErr_Occurred()) SWIG_fail;
20792 }
20793 resultobj = SWIG_From_int(static_cast< int >(result));
20794 return resultobj;
20795 fail:
20796 return NULL;
20797 }
20798
20799
20800 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20801 PyObject *resultobj = 0;
20802 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20803 int result;
20804 void *argp1 = 0 ;
20805 int res1 = 0 ;
20806 PyObject *swig_obj[1] ;
20807
20808 if (!args) SWIG_fail;
20809 swig_obj[0] = args;
20810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20811 if (!SWIG_IsOK(res1)) {
20812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20813 }
20814 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20815 {
20816 PyThreadState* __tstate = wxPyBeginAllowThreads();
20817 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20818 wxPyEndAllowThreads(__tstate);
20819 if (PyErr_Occurred()) SWIG_fail;
20820 }
20821 resultobj = SWIG_From_int(static_cast< int >(result));
20822 return resultobj;
20823 fail:
20824 return NULL;
20825 }
20826
20827
20828 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20829 PyObject *resultobj = 0;
20830 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20831 int result;
20832 void *argp1 = 0 ;
20833 int res1 = 0 ;
20834 PyObject *swig_obj[1] ;
20835
20836 if (!args) SWIG_fail;
20837 swig_obj[0] = args;
20838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20839 if (!SWIG_IsOK(res1)) {
20840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20841 }
20842 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20843 {
20844 PyThreadState* __tstate = wxPyBeginAllowThreads();
20845 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20846 wxPyEndAllowThreads(__tstate);
20847 if (PyErr_Occurred()) SWIG_fail;
20848 }
20849 resultobj = SWIG_From_int(static_cast< int >(result));
20850 return resultobj;
20851 fail:
20852 return NULL;
20853 }
20854
20855
20856 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20857 PyObject *resultobj = 0;
20858 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20859 bool result;
20860 void *argp1 = 0 ;
20861 int res1 = 0 ;
20862 PyObject *swig_obj[1] ;
20863
20864 if (!args) SWIG_fail;
20865 swig_obj[0] = args;
20866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20867 if (!SWIG_IsOK(res1)) {
20868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20869 }
20870 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20871 {
20872 PyThreadState* __tstate = wxPyBeginAllowThreads();
20873 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20874 wxPyEndAllowThreads(__tstate);
20875 if (PyErr_Occurred()) SWIG_fail;
20876 }
20877 {
20878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20879 }
20880 return resultobj;
20881 fail:
20882 return NULL;
20883 }
20884
20885
20886 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20887 PyObject *resultobj = 0;
20888 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20889 int arg2 ;
20890 void *argp1 = 0 ;
20891 int res1 = 0 ;
20892 int val2 ;
20893 int ecode2 = 0 ;
20894 PyObject *swig_obj[2] ;
20895
20896 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20898 if (!SWIG_IsOK(res1)) {
20899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20900 }
20901 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20902 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20903 if (!SWIG_IsOK(ecode2)) {
20904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20905 }
20906 arg2 = static_cast< int >(val2);
20907 if (arg1) (arg1)->m_x = arg2;
20908
20909 resultobj = SWIG_Py_Void();
20910 return resultobj;
20911 fail:
20912 return NULL;
20913 }
20914
20915
20916 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20917 PyObject *resultobj = 0;
20918 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20919 int result;
20920 void *argp1 = 0 ;
20921 int res1 = 0 ;
20922 PyObject *swig_obj[1] ;
20923
20924 if (!args) SWIG_fail;
20925 swig_obj[0] = args;
20926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20927 if (!SWIG_IsOK(res1)) {
20928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20929 }
20930 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20931 result = (int) ((arg1)->m_x);
20932 resultobj = SWIG_From_int(static_cast< int >(result));
20933 return resultobj;
20934 fail:
20935 return NULL;
20936 }
20937
20938
20939 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20940 PyObject *resultobj = 0;
20941 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20942 int arg2 ;
20943 void *argp1 = 0 ;
20944 int res1 = 0 ;
20945 int val2 ;
20946 int ecode2 = 0 ;
20947 PyObject *swig_obj[2] ;
20948
20949 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
20950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20951 if (!SWIG_IsOK(res1)) {
20952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20953 }
20954 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20955 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20956 if (!SWIG_IsOK(ecode2)) {
20957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
20958 }
20959 arg2 = static_cast< int >(val2);
20960 if (arg1) (arg1)->m_y = arg2;
20961
20962 resultobj = SWIG_Py_Void();
20963 return resultobj;
20964 fail:
20965 return NULL;
20966 }
20967
20968
20969 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20970 PyObject *resultobj = 0;
20971 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20972 int result;
20973 void *argp1 = 0 ;
20974 int res1 = 0 ;
20975 PyObject *swig_obj[1] ;
20976
20977 if (!args) SWIG_fail;
20978 swig_obj[0] = args;
20979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20980 if (!SWIG_IsOK(res1)) {
20981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20982 }
20983 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20984 result = (int) ((arg1)->m_y);
20985 resultobj = SWIG_From_int(static_cast< int >(result));
20986 return resultobj;
20987 fail:
20988 return NULL;
20989 }
20990
20991
20992 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20993 PyObject *resultobj = 0;
20994 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20995 bool arg2 ;
20996 void *argp1 = 0 ;
20997 int res1 = 0 ;
20998 bool val2 ;
20999 int ecode2 = 0 ;
21000 PyObject *swig_obj[2] ;
21001
21002 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21004 if (!SWIG_IsOK(res1)) {
21005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21006 }
21007 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21008 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21009 if (!SWIG_IsOK(ecode2)) {
21010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21011 }
21012 arg2 = static_cast< bool >(val2);
21013 if (arg1) (arg1)->m_leftDown = arg2;
21014
21015 resultobj = SWIG_Py_Void();
21016 return resultobj;
21017 fail:
21018 return NULL;
21019 }
21020
21021
21022 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21023 PyObject *resultobj = 0;
21024 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21025 bool result;
21026 void *argp1 = 0 ;
21027 int res1 = 0 ;
21028 PyObject *swig_obj[1] ;
21029
21030 if (!args) SWIG_fail;
21031 swig_obj[0] = args;
21032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21033 if (!SWIG_IsOK(res1)) {
21034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21035 }
21036 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21037 result = (bool) ((arg1)->m_leftDown);
21038 {
21039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21040 }
21041 return resultobj;
21042 fail:
21043 return NULL;
21044 }
21045
21046
21047 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21048 PyObject *resultobj = 0;
21049 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21050 bool arg2 ;
21051 void *argp1 = 0 ;
21052 int res1 = 0 ;
21053 bool val2 ;
21054 int ecode2 = 0 ;
21055 PyObject *swig_obj[2] ;
21056
21057 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21059 if (!SWIG_IsOK(res1)) {
21060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21061 }
21062 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21063 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21064 if (!SWIG_IsOK(ecode2)) {
21065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21066 }
21067 arg2 = static_cast< bool >(val2);
21068 if (arg1) (arg1)->m_middleDown = arg2;
21069
21070 resultobj = SWIG_Py_Void();
21071 return resultobj;
21072 fail:
21073 return NULL;
21074 }
21075
21076
21077 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21078 PyObject *resultobj = 0;
21079 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21080 bool result;
21081 void *argp1 = 0 ;
21082 int res1 = 0 ;
21083 PyObject *swig_obj[1] ;
21084
21085 if (!args) SWIG_fail;
21086 swig_obj[0] = args;
21087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21088 if (!SWIG_IsOK(res1)) {
21089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21090 }
21091 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21092 result = (bool) ((arg1)->m_middleDown);
21093 {
21094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21095 }
21096 return resultobj;
21097 fail:
21098 return NULL;
21099 }
21100
21101
21102 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21103 PyObject *resultobj = 0;
21104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21105 bool arg2 ;
21106 void *argp1 = 0 ;
21107 int res1 = 0 ;
21108 bool val2 ;
21109 int ecode2 = 0 ;
21110 PyObject *swig_obj[2] ;
21111
21112 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21114 if (!SWIG_IsOK(res1)) {
21115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21116 }
21117 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21118 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21119 if (!SWIG_IsOK(ecode2)) {
21120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21121 }
21122 arg2 = static_cast< bool >(val2);
21123 if (arg1) (arg1)->m_rightDown = arg2;
21124
21125 resultobj = SWIG_Py_Void();
21126 return resultobj;
21127 fail:
21128 return NULL;
21129 }
21130
21131
21132 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21133 PyObject *resultobj = 0;
21134 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21135 bool result;
21136 void *argp1 = 0 ;
21137 int res1 = 0 ;
21138 PyObject *swig_obj[1] ;
21139
21140 if (!args) SWIG_fail;
21141 swig_obj[0] = args;
21142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21143 if (!SWIG_IsOK(res1)) {
21144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21145 }
21146 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21147 result = (bool) ((arg1)->m_rightDown);
21148 {
21149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21150 }
21151 return resultobj;
21152 fail:
21153 return NULL;
21154 }
21155
21156
21157 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21158 PyObject *resultobj = 0;
21159 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21160 bool arg2 ;
21161 void *argp1 = 0 ;
21162 int res1 = 0 ;
21163 bool val2 ;
21164 int ecode2 = 0 ;
21165 PyObject *swig_obj[2] ;
21166
21167 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21169 if (!SWIG_IsOK(res1)) {
21170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21171 }
21172 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21173 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21174 if (!SWIG_IsOK(ecode2)) {
21175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21176 }
21177 arg2 = static_cast< bool >(val2);
21178 if (arg1) (arg1)->m_controlDown = arg2;
21179
21180 resultobj = SWIG_Py_Void();
21181 return resultobj;
21182 fail:
21183 return NULL;
21184 }
21185
21186
21187 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21188 PyObject *resultobj = 0;
21189 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21190 bool result;
21191 void *argp1 = 0 ;
21192 int res1 = 0 ;
21193 PyObject *swig_obj[1] ;
21194
21195 if (!args) SWIG_fail;
21196 swig_obj[0] = args;
21197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21198 if (!SWIG_IsOK(res1)) {
21199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21200 }
21201 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21202 result = (bool) ((arg1)->m_controlDown);
21203 {
21204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21205 }
21206 return resultobj;
21207 fail:
21208 return NULL;
21209 }
21210
21211
21212 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21213 PyObject *resultobj = 0;
21214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21215 bool arg2 ;
21216 void *argp1 = 0 ;
21217 int res1 = 0 ;
21218 bool val2 ;
21219 int ecode2 = 0 ;
21220 PyObject *swig_obj[2] ;
21221
21222 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21224 if (!SWIG_IsOK(res1)) {
21225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21226 }
21227 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21228 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21229 if (!SWIG_IsOK(ecode2)) {
21230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21231 }
21232 arg2 = static_cast< bool >(val2);
21233 if (arg1) (arg1)->m_shiftDown = arg2;
21234
21235 resultobj = SWIG_Py_Void();
21236 return resultobj;
21237 fail:
21238 return NULL;
21239 }
21240
21241
21242 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21243 PyObject *resultobj = 0;
21244 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21245 bool result;
21246 void *argp1 = 0 ;
21247 int res1 = 0 ;
21248 PyObject *swig_obj[1] ;
21249
21250 if (!args) SWIG_fail;
21251 swig_obj[0] = args;
21252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21253 if (!SWIG_IsOK(res1)) {
21254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21255 }
21256 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21257 result = (bool) ((arg1)->m_shiftDown);
21258 {
21259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21260 }
21261 return resultobj;
21262 fail:
21263 return NULL;
21264 }
21265
21266
21267 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21268 PyObject *resultobj = 0;
21269 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21270 bool arg2 ;
21271 void *argp1 = 0 ;
21272 int res1 = 0 ;
21273 bool val2 ;
21274 int ecode2 = 0 ;
21275 PyObject *swig_obj[2] ;
21276
21277 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21279 if (!SWIG_IsOK(res1)) {
21280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21281 }
21282 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21283 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21284 if (!SWIG_IsOK(ecode2)) {
21285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21286 }
21287 arg2 = static_cast< bool >(val2);
21288 if (arg1) (arg1)->m_altDown = arg2;
21289
21290 resultobj = SWIG_Py_Void();
21291 return resultobj;
21292 fail:
21293 return NULL;
21294 }
21295
21296
21297 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21298 PyObject *resultobj = 0;
21299 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21300 bool result;
21301 void *argp1 = 0 ;
21302 int res1 = 0 ;
21303 PyObject *swig_obj[1] ;
21304
21305 if (!args) SWIG_fail;
21306 swig_obj[0] = args;
21307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21308 if (!SWIG_IsOK(res1)) {
21309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21310 }
21311 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21312 result = (bool) ((arg1)->m_altDown);
21313 {
21314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21315 }
21316 return resultobj;
21317 fail:
21318 return NULL;
21319 }
21320
21321
21322 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21323 PyObject *resultobj = 0;
21324 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21325 bool arg2 ;
21326 void *argp1 = 0 ;
21327 int res1 = 0 ;
21328 bool val2 ;
21329 int ecode2 = 0 ;
21330 PyObject *swig_obj[2] ;
21331
21332 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21334 if (!SWIG_IsOK(res1)) {
21335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21336 }
21337 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21338 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21339 if (!SWIG_IsOK(ecode2)) {
21340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21341 }
21342 arg2 = static_cast< bool >(val2);
21343 if (arg1) (arg1)->m_metaDown = arg2;
21344
21345 resultobj = SWIG_Py_Void();
21346 return resultobj;
21347 fail:
21348 return NULL;
21349 }
21350
21351
21352 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21353 PyObject *resultobj = 0;
21354 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21355 bool result;
21356 void *argp1 = 0 ;
21357 int res1 = 0 ;
21358 PyObject *swig_obj[1] ;
21359
21360 if (!args) SWIG_fail;
21361 swig_obj[0] = args;
21362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21363 if (!SWIG_IsOK(res1)) {
21364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21365 }
21366 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21367 result = (bool) ((arg1)->m_metaDown);
21368 {
21369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21370 }
21371 return resultobj;
21372 fail:
21373 return NULL;
21374 }
21375
21376
21377 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21378 PyObject *resultobj = 0;
21379 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21380 int arg2 ;
21381 void *argp1 = 0 ;
21382 int res1 = 0 ;
21383 int val2 ;
21384 int ecode2 = 0 ;
21385 PyObject *swig_obj[2] ;
21386
21387 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21389 if (!SWIG_IsOK(res1)) {
21390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21391 }
21392 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21393 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21394 if (!SWIG_IsOK(ecode2)) {
21395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21396 }
21397 arg2 = static_cast< int >(val2);
21398 if (arg1) (arg1)->m_wheelRotation = arg2;
21399
21400 resultobj = SWIG_Py_Void();
21401 return resultobj;
21402 fail:
21403 return NULL;
21404 }
21405
21406
21407 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21408 PyObject *resultobj = 0;
21409 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21410 int result;
21411 void *argp1 = 0 ;
21412 int res1 = 0 ;
21413 PyObject *swig_obj[1] ;
21414
21415 if (!args) SWIG_fail;
21416 swig_obj[0] = args;
21417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21418 if (!SWIG_IsOK(res1)) {
21419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21420 }
21421 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21422 result = (int) ((arg1)->m_wheelRotation);
21423 resultobj = SWIG_From_int(static_cast< int >(result));
21424 return resultobj;
21425 fail:
21426 return NULL;
21427 }
21428
21429
21430 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21431 PyObject *resultobj = 0;
21432 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21433 int arg2 ;
21434 void *argp1 = 0 ;
21435 int res1 = 0 ;
21436 int val2 ;
21437 int ecode2 = 0 ;
21438 PyObject *swig_obj[2] ;
21439
21440 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21442 if (!SWIG_IsOK(res1)) {
21443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21444 }
21445 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21446 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21447 if (!SWIG_IsOK(ecode2)) {
21448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21449 }
21450 arg2 = static_cast< int >(val2);
21451 if (arg1) (arg1)->m_wheelDelta = arg2;
21452
21453 resultobj = SWIG_Py_Void();
21454 return resultobj;
21455 fail:
21456 return NULL;
21457 }
21458
21459
21460 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21461 PyObject *resultobj = 0;
21462 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21463 int result;
21464 void *argp1 = 0 ;
21465 int res1 = 0 ;
21466 PyObject *swig_obj[1] ;
21467
21468 if (!args) SWIG_fail;
21469 swig_obj[0] = args;
21470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21471 if (!SWIG_IsOK(res1)) {
21472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21473 }
21474 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21475 result = (int) ((arg1)->m_wheelDelta);
21476 resultobj = SWIG_From_int(static_cast< int >(result));
21477 return resultobj;
21478 fail:
21479 return NULL;
21480 }
21481
21482
21483 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21484 PyObject *resultobj = 0;
21485 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21486 int arg2 ;
21487 void *argp1 = 0 ;
21488 int res1 = 0 ;
21489 int val2 ;
21490 int ecode2 = 0 ;
21491 PyObject *swig_obj[2] ;
21492
21493 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21495 if (!SWIG_IsOK(res1)) {
21496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21497 }
21498 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21499 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21500 if (!SWIG_IsOK(ecode2)) {
21501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21502 }
21503 arg2 = static_cast< int >(val2);
21504 if (arg1) (arg1)->m_linesPerAction = arg2;
21505
21506 resultobj = SWIG_Py_Void();
21507 return resultobj;
21508 fail:
21509 return NULL;
21510 }
21511
21512
21513 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21514 PyObject *resultobj = 0;
21515 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21516 int result;
21517 void *argp1 = 0 ;
21518 int res1 = 0 ;
21519 PyObject *swig_obj[1] ;
21520
21521 if (!args) SWIG_fail;
21522 swig_obj[0] = args;
21523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21524 if (!SWIG_IsOK(res1)) {
21525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21526 }
21527 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21528 result = (int) ((arg1)->m_linesPerAction);
21529 resultobj = SWIG_From_int(static_cast< int >(result));
21530 return resultobj;
21531 fail:
21532 return NULL;
21533 }
21534
21535
21536 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21537 PyObject *obj;
21538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21539 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21540 return SWIG_Py_Void();
21541 }
21542
21543 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21544 return SWIG_Python_InitShadowInstance(args);
21545 }
21546
21547 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21548 PyObject *resultobj = 0;
21549 int arg1 = (int) 0 ;
21550 int arg2 = (int) 0 ;
21551 wxSetCursorEvent *result = 0 ;
21552 int val1 ;
21553 int ecode1 = 0 ;
21554 int val2 ;
21555 int ecode2 = 0 ;
21556 PyObject * obj0 = 0 ;
21557 PyObject * obj1 = 0 ;
21558 char * kwnames[] = {
21559 (char *) "x",(char *) "y", NULL
21560 };
21561
21562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21563 if (obj0) {
21564 ecode1 = SWIG_AsVal_int(obj0, &val1);
21565 if (!SWIG_IsOK(ecode1)) {
21566 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21567 }
21568 arg1 = static_cast< int >(val1);
21569 }
21570 if (obj1) {
21571 ecode2 = SWIG_AsVal_int(obj1, &val2);
21572 if (!SWIG_IsOK(ecode2)) {
21573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21574 }
21575 arg2 = static_cast< int >(val2);
21576 }
21577 {
21578 PyThreadState* __tstate = wxPyBeginAllowThreads();
21579 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21580 wxPyEndAllowThreads(__tstate);
21581 if (PyErr_Occurred()) SWIG_fail;
21582 }
21583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21584 return resultobj;
21585 fail:
21586 return NULL;
21587 }
21588
21589
21590 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21591 PyObject *resultobj = 0;
21592 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21593 int result;
21594 void *argp1 = 0 ;
21595 int res1 = 0 ;
21596 PyObject *swig_obj[1] ;
21597
21598 if (!args) SWIG_fail;
21599 swig_obj[0] = args;
21600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21601 if (!SWIG_IsOK(res1)) {
21602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21603 }
21604 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21605 {
21606 PyThreadState* __tstate = wxPyBeginAllowThreads();
21607 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21608 wxPyEndAllowThreads(__tstate);
21609 if (PyErr_Occurred()) SWIG_fail;
21610 }
21611 resultobj = SWIG_From_int(static_cast< int >(result));
21612 return resultobj;
21613 fail:
21614 return NULL;
21615 }
21616
21617
21618 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21619 PyObject *resultobj = 0;
21620 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 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_wxSetCursorEvent, 0 | 0 );
21629 if (!SWIG_IsOK(res1)) {
21630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21631 }
21632 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21633 {
21634 PyThreadState* __tstate = wxPyBeginAllowThreads();
21635 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21636 wxPyEndAllowThreads(__tstate);
21637 if (PyErr_Occurred()) SWIG_fail;
21638 }
21639 resultobj = SWIG_From_int(static_cast< int >(result));
21640 return resultobj;
21641 fail:
21642 return NULL;
21643 }
21644
21645
21646 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21647 PyObject *resultobj = 0;
21648 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21649 wxCursor *arg2 = 0 ;
21650 void *argp1 = 0 ;
21651 int res1 = 0 ;
21652 void *argp2 = 0 ;
21653 int res2 = 0 ;
21654 PyObject * obj0 = 0 ;
21655 PyObject * obj1 = 0 ;
21656 char * kwnames[] = {
21657 (char *) "self",(char *) "cursor", NULL
21658 };
21659
21660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21662 if (!SWIG_IsOK(res1)) {
21663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21664 }
21665 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21666 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21667 if (!SWIG_IsOK(res2)) {
21668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21669 }
21670 if (!argp2) {
21671 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21672 }
21673 arg2 = reinterpret_cast< wxCursor * >(argp2);
21674 {
21675 PyThreadState* __tstate = wxPyBeginAllowThreads();
21676 (arg1)->SetCursor((wxCursor const &)*arg2);
21677 wxPyEndAllowThreads(__tstate);
21678 if (PyErr_Occurred()) SWIG_fail;
21679 }
21680 resultobj = SWIG_Py_Void();
21681 return resultobj;
21682 fail:
21683 return NULL;
21684 }
21685
21686
21687 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21688 PyObject *resultobj = 0;
21689 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21690 wxCursor *result = 0 ;
21691 void *argp1 = 0 ;
21692 int res1 = 0 ;
21693 PyObject *swig_obj[1] ;
21694
21695 if (!args) SWIG_fail;
21696 swig_obj[0] = args;
21697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21698 if (!SWIG_IsOK(res1)) {
21699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21700 }
21701 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21702 {
21703 PyThreadState* __tstate = wxPyBeginAllowThreads();
21704 {
21705 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21706 result = (wxCursor *) &_result_ref;
21707 }
21708 wxPyEndAllowThreads(__tstate);
21709 if (PyErr_Occurred()) SWIG_fail;
21710 }
21711 {
21712 wxCursor* resultptr = new wxCursor(*result);
21713 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21714 }
21715 return resultobj;
21716 fail:
21717 return NULL;
21718 }
21719
21720
21721 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21722 PyObject *resultobj = 0;
21723 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21724 bool result;
21725 void *argp1 = 0 ;
21726 int res1 = 0 ;
21727 PyObject *swig_obj[1] ;
21728
21729 if (!args) SWIG_fail;
21730 swig_obj[0] = args;
21731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21732 if (!SWIG_IsOK(res1)) {
21733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21734 }
21735 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21736 {
21737 PyThreadState* __tstate = wxPyBeginAllowThreads();
21738 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21739 wxPyEndAllowThreads(__tstate);
21740 if (PyErr_Occurred()) SWIG_fail;
21741 }
21742 {
21743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21744 }
21745 return resultobj;
21746 fail:
21747 return NULL;
21748 }
21749
21750
21751 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21752 PyObject *obj;
21753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21754 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21755 return SWIG_Py_Void();
21756 }
21757
21758 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21759 return SWIG_Python_InitShadowInstance(args);
21760 }
21761
21762 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21763 PyObject *resultobj = 0;
21764 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21765 wxKeyEvent *result = 0 ;
21766 int val1 ;
21767 int ecode1 = 0 ;
21768 PyObject * obj0 = 0 ;
21769 char * kwnames[] = {
21770 (char *) "eventType", NULL
21771 };
21772
21773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21774 if (obj0) {
21775 ecode1 = SWIG_AsVal_int(obj0, &val1);
21776 if (!SWIG_IsOK(ecode1)) {
21777 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21778 }
21779 arg1 = static_cast< wxEventType >(val1);
21780 }
21781 {
21782 PyThreadState* __tstate = wxPyBeginAllowThreads();
21783 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21784 wxPyEndAllowThreads(__tstate);
21785 if (PyErr_Occurred()) SWIG_fail;
21786 }
21787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21788 return resultobj;
21789 fail:
21790 return NULL;
21791 }
21792
21793
21794 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21795 PyObject *resultobj = 0;
21796 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21797 int result;
21798 void *argp1 = 0 ;
21799 int res1 = 0 ;
21800 PyObject *swig_obj[1] ;
21801
21802 if (!args) SWIG_fail;
21803 swig_obj[0] = args;
21804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21805 if (!SWIG_IsOK(res1)) {
21806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21807 }
21808 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21809 {
21810 PyThreadState* __tstate = wxPyBeginAllowThreads();
21811 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21812 wxPyEndAllowThreads(__tstate);
21813 if (PyErr_Occurred()) SWIG_fail;
21814 }
21815 resultobj = SWIG_From_int(static_cast< int >(result));
21816 return resultobj;
21817 fail:
21818 return NULL;
21819 }
21820
21821
21822 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21823 PyObject *resultobj = 0;
21824 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21825 bool result;
21826 void *argp1 = 0 ;
21827 int res1 = 0 ;
21828 PyObject *swig_obj[1] ;
21829
21830 if (!args) SWIG_fail;
21831 swig_obj[0] = args;
21832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21833 if (!SWIG_IsOK(res1)) {
21834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21835 }
21836 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21837 {
21838 PyThreadState* __tstate = wxPyBeginAllowThreads();
21839 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21840 wxPyEndAllowThreads(__tstate);
21841 if (PyErr_Occurred()) SWIG_fail;
21842 }
21843 {
21844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21845 }
21846 return resultobj;
21847 fail:
21848 return NULL;
21849 }
21850
21851
21852 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21853 PyObject *resultobj = 0;
21854 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21855 bool result;
21856 void *argp1 = 0 ;
21857 int res1 = 0 ;
21858 PyObject *swig_obj[1] ;
21859
21860 if (!args) SWIG_fail;
21861 swig_obj[0] = args;
21862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21863 if (!SWIG_IsOK(res1)) {
21864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21865 }
21866 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21867 {
21868 PyThreadState* __tstate = wxPyBeginAllowThreads();
21869 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21870 wxPyEndAllowThreads(__tstate);
21871 if (PyErr_Occurred()) SWIG_fail;
21872 }
21873 {
21874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21875 }
21876 return resultobj;
21877 fail:
21878 return NULL;
21879 }
21880
21881
21882 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21883 PyObject *resultobj = 0;
21884 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21885 bool result;
21886 void *argp1 = 0 ;
21887 int res1 = 0 ;
21888 PyObject *swig_obj[1] ;
21889
21890 if (!args) SWIG_fail;
21891 swig_obj[0] = args;
21892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21893 if (!SWIG_IsOK(res1)) {
21894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21895 }
21896 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21897 {
21898 PyThreadState* __tstate = wxPyBeginAllowThreads();
21899 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21900 wxPyEndAllowThreads(__tstate);
21901 if (PyErr_Occurred()) SWIG_fail;
21902 }
21903 {
21904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21905 }
21906 return resultobj;
21907 fail:
21908 return NULL;
21909 }
21910
21911
21912 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21913 PyObject *resultobj = 0;
21914 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21915 bool result;
21916 void *argp1 = 0 ;
21917 int res1 = 0 ;
21918 PyObject *swig_obj[1] ;
21919
21920 if (!args) SWIG_fail;
21921 swig_obj[0] = args;
21922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21923 if (!SWIG_IsOK(res1)) {
21924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21925 }
21926 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21927 {
21928 PyThreadState* __tstate = wxPyBeginAllowThreads();
21929 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
21930 wxPyEndAllowThreads(__tstate);
21931 if (PyErr_Occurred()) SWIG_fail;
21932 }
21933 {
21934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21935 }
21936 return resultobj;
21937 fail:
21938 return NULL;
21939 }
21940
21941
21942 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21943 PyObject *resultobj = 0;
21944 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21945 bool result;
21946 void *argp1 = 0 ;
21947 int res1 = 0 ;
21948 PyObject *swig_obj[1] ;
21949
21950 if (!args) SWIG_fail;
21951 swig_obj[0] = args;
21952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21953 if (!SWIG_IsOK(res1)) {
21954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21955 }
21956 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21957 {
21958 PyThreadState* __tstate = wxPyBeginAllowThreads();
21959 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
21960 wxPyEndAllowThreads(__tstate);
21961 if (PyErr_Occurred()) SWIG_fail;
21962 }
21963 {
21964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21965 }
21966 return resultobj;
21967 fail:
21968 return NULL;
21969 }
21970
21971
21972 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21973 PyObject *resultobj = 0;
21974 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21975 bool result;
21976 void *argp1 = 0 ;
21977 int res1 = 0 ;
21978 PyObject *swig_obj[1] ;
21979
21980 if (!args) SWIG_fail;
21981 swig_obj[0] = args;
21982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21983 if (!SWIG_IsOK(res1)) {
21984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21985 }
21986 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 {
21994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21995 }
21996 return resultobj;
21997 fail:
21998 return NULL;
21999 }
22000
22001
22002 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22003 PyObject *resultobj = 0;
22004 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22005 int result;
22006 void *argp1 = 0 ;
22007 int res1 = 0 ;
22008 PyObject *swig_obj[1] ;
22009
22010 if (!args) SWIG_fail;
22011 swig_obj[0] = args;
22012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22013 if (!SWIG_IsOK(res1)) {
22014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22015 }
22016 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22017 {
22018 PyThreadState* __tstate = wxPyBeginAllowThreads();
22019 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22020 wxPyEndAllowThreads(__tstate);
22021 if (PyErr_Occurred()) SWIG_fail;
22022 }
22023 resultobj = SWIG_From_int(static_cast< int >(result));
22024 return resultobj;
22025 fail:
22026 return NULL;
22027 }
22028
22029
22030 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22031 PyObject *resultobj = 0;
22032 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22033 int result;
22034 void *argp1 = 0 ;
22035 int res1 = 0 ;
22036 PyObject *swig_obj[1] ;
22037
22038 if (!args) SWIG_fail;
22039 swig_obj[0] = args;
22040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22041 if (!SWIG_IsOK(res1)) {
22042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22043 }
22044 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22045 {
22046 PyThreadState* __tstate = wxPyBeginAllowThreads();
22047 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22048 wxPyEndAllowThreads(__tstate);
22049 if (PyErr_Occurred()) SWIG_fail;
22050 }
22051 resultobj = SWIG_From_int(static_cast< int >(result));
22052 return resultobj;
22053 fail:
22054 return NULL;
22055 }
22056
22057
22058 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22059 PyObject *resultobj = 0;
22060 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22061 unsigned int result;
22062 void *argp1 = 0 ;
22063 int res1 = 0 ;
22064 PyObject *swig_obj[1] ;
22065
22066 if (!args) SWIG_fail;
22067 swig_obj[0] = args;
22068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22069 if (!SWIG_IsOK(res1)) {
22070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22071 }
22072 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22073 {
22074 PyThreadState* __tstate = wxPyBeginAllowThreads();
22075 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22076 wxPyEndAllowThreads(__tstate);
22077 if (PyErr_Occurred()) SWIG_fail;
22078 }
22079 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22080 return resultobj;
22081 fail:
22082 return NULL;
22083 }
22084
22085
22086 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22087 PyObject *resultobj = 0;
22088 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22089 unsigned int result;
22090 void *argp1 = 0 ;
22091 int res1 = 0 ;
22092 PyObject *swig_obj[1] ;
22093
22094 if (!args) SWIG_fail;
22095 swig_obj[0] = args;
22096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22097 if (!SWIG_IsOK(res1)) {
22098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22099 }
22100 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22101 {
22102 PyThreadState* __tstate = wxPyBeginAllowThreads();
22103 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22104 wxPyEndAllowThreads(__tstate);
22105 if (PyErr_Occurred()) SWIG_fail;
22106 }
22107 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22108 return resultobj;
22109 fail:
22110 return NULL;
22111 }
22112
22113
22114 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22115 PyObject *resultobj = 0;
22116 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22117 wxPoint result;
22118 void *argp1 = 0 ;
22119 int res1 = 0 ;
22120 PyObject *swig_obj[1] ;
22121
22122 if (!args) SWIG_fail;
22123 swig_obj[0] = args;
22124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22125 if (!SWIG_IsOK(res1)) {
22126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22127 }
22128 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22129 {
22130 PyThreadState* __tstate = wxPyBeginAllowThreads();
22131 result = (arg1)->GetPosition();
22132 wxPyEndAllowThreads(__tstate);
22133 if (PyErr_Occurred()) SWIG_fail;
22134 }
22135 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22136 return resultobj;
22137 fail:
22138 return NULL;
22139 }
22140
22141
22142 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22143 PyObject *resultobj = 0;
22144 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22145 long *arg2 = (long *) 0 ;
22146 long *arg3 = (long *) 0 ;
22147 void *argp1 = 0 ;
22148 int res1 = 0 ;
22149 long temp2 ;
22150 int res2 = SWIG_TMPOBJ ;
22151 long temp3 ;
22152 int res3 = SWIG_TMPOBJ ;
22153 PyObject *swig_obj[1] ;
22154
22155 arg2 = &temp2;
22156 arg3 = &temp3;
22157 if (!args) SWIG_fail;
22158 swig_obj[0] = args;
22159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22160 if (!SWIG_IsOK(res1)) {
22161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22162 }
22163 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22164 {
22165 PyThreadState* __tstate = wxPyBeginAllowThreads();
22166 (arg1)->GetPosition(arg2,arg3);
22167 wxPyEndAllowThreads(__tstate);
22168 if (PyErr_Occurred()) SWIG_fail;
22169 }
22170 resultobj = SWIG_Py_Void();
22171 if (SWIG_IsTmpObj(res2)) {
22172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22173 } else {
22174 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22176 }
22177 if (SWIG_IsTmpObj(res3)) {
22178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22179 } else {
22180 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22182 }
22183 return resultobj;
22184 fail:
22185 return NULL;
22186 }
22187
22188
22189 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22190 PyObject *resultobj = 0;
22191 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22192 int result;
22193 void *argp1 = 0 ;
22194 int res1 = 0 ;
22195 PyObject *swig_obj[1] ;
22196
22197 if (!args) SWIG_fail;
22198 swig_obj[0] = args;
22199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22200 if (!SWIG_IsOK(res1)) {
22201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22202 }
22203 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22204 {
22205 PyThreadState* __tstate = wxPyBeginAllowThreads();
22206 result = (int)((wxKeyEvent const *)arg1)->GetX();
22207 wxPyEndAllowThreads(__tstate);
22208 if (PyErr_Occurred()) SWIG_fail;
22209 }
22210 resultobj = SWIG_From_int(static_cast< int >(result));
22211 return resultobj;
22212 fail:
22213 return NULL;
22214 }
22215
22216
22217 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22218 PyObject *resultobj = 0;
22219 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22220 int result;
22221 void *argp1 = 0 ;
22222 int res1 = 0 ;
22223 PyObject *swig_obj[1] ;
22224
22225 if (!args) SWIG_fail;
22226 swig_obj[0] = args;
22227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22228 if (!SWIG_IsOK(res1)) {
22229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22230 }
22231 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22232 {
22233 PyThreadState* __tstate = wxPyBeginAllowThreads();
22234 result = (int)((wxKeyEvent const *)arg1)->GetY();
22235 wxPyEndAllowThreads(__tstate);
22236 if (PyErr_Occurred()) SWIG_fail;
22237 }
22238 resultobj = SWIG_From_int(static_cast< int >(result));
22239 return resultobj;
22240 fail:
22241 return NULL;
22242 }
22243
22244
22245 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22246 PyObject *resultobj = 0;
22247 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22248 int arg2 ;
22249 void *argp1 = 0 ;
22250 int res1 = 0 ;
22251 int val2 ;
22252 int ecode2 = 0 ;
22253 PyObject *swig_obj[2] ;
22254
22255 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22257 if (!SWIG_IsOK(res1)) {
22258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22259 }
22260 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22261 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22262 if (!SWIG_IsOK(ecode2)) {
22263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22264 }
22265 arg2 = static_cast< int >(val2);
22266 if (arg1) (arg1)->m_x = arg2;
22267
22268 resultobj = SWIG_Py_Void();
22269 return resultobj;
22270 fail:
22271 return NULL;
22272 }
22273
22274
22275 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22276 PyObject *resultobj = 0;
22277 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22278 int result;
22279 void *argp1 = 0 ;
22280 int res1 = 0 ;
22281 PyObject *swig_obj[1] ;
22282
22283 if (!args) SWIG_fail;
22284 swig_obj[0] = args;
22285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22286 if (!SWIG_IsOK(res1)) {
22287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22288 }
22289 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22290 result = (int) ((arg1)->m_x);
22291 resultobj = SWIG_From_int(static_cast< int >(result));
22292 return resultobj;
22293 fail:
22294 return NULL;
22295 }
22296
22297
22298 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22299 PyObject *resultobj = 0;
22300 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22301 int arg2 ;
22302 void *argp1 = 0 ;
22303 int res1 = 0 ;
22304 int val2 ;
22305 int ecode2 = 0 ;
22306 PyObject *swig_obj[2] ;
22307
22308 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22310 if (!SWIG_IsOK(res1)) {
22311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22312 }
22313 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22314 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22315 if (!SWIG_IsOK(ecode2)) {
22316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22317 }
22318 arg2 = static_cast< int >(val2);
22319 if (arg1) (arg1)->m_y = arg2;
22320
22321 resultobj = SWIG_Py_Void();
22322 return resultobj;
22323 fail:
22324 return NULL;
22325 }
22326
22327
22328 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22329 PyObject *resultobj = 0;
22330 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22331 int result;
22332 void *argp1 = 0 ;
22333 int res1 = 0 ;
22334 PyObject *swig_obj[1] ;
22335
22336 if (!args) SWIG_fail;
22337 swig_obj[0] = args;
22338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22339 if (!SWIG_IsOK(res1)) {
22340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22341 }
22342 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22343 result = (int) ((arg1)->m_y);
22344 resultobj = SWIG_From_int(static_cast< int >(result));
22345 return resultobj;
22346 fail:
22347 return NULL;
22348 }
22349
22350
22351 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22352 PyObject *resultobj = 0;
22353 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22354 long arg2 ;
22355 void *argp1 = 0 ;
22356 int res1 = 0 ;
22357 long val2 ;
22358 int ecode2 = 0 ;
22359 PyObject *swig_obj[2] ;
22360
22361 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22363 if (!SWIG_IsOK(res1)) {
22364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22365 }
22366 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22367 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22368 if (!SWIG_IsOK(ecode2)) {
22369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22370 }
22371 arg2 = static_cast< long >(val2);
22372 if (arg1) (arg1)->m_keyCode = arg2;
22373
22374 resultobj = SWIG_Py_Void();
22375 return resultobj;
22376 fail:
22377 return NULL;
22378 }
22379
22380
22381 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22382 PyObject *resultobj = 0;
22383 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22384 long result;
22385 void *argp1 = 0 ;
22386 int res1 = 0 ;
22387 PyObject *swig_obj[1] ;
22388
22389 if (!args) SWIG_fail;
22390 swig_obj[0] = args;
22391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22392 if (!SWIG_IsOK(res1)) {
22393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22394 }
22395 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22396 result = (long) ((arg1)->m_keyCode);
22397 resultobj = SWIG_From_long(static_cast< long >(result));
22398 return resultobj;
22399 fail:
22400 return NULL;
22401 }
22402
22403
22404 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22405 PyObject *resultobj = 0;
22406 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22407 bool arg2 ;
22408 void *argp1 = 0 ;
22409 int res1 = 0 ;
22410 bool val2 ;
22411 int ecode2 = 0 ;
22412 PyObject *swig_obj[2] ;
22413
22414 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22416 if (!SWIG_IsOK(res1)) {
22417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22418 }
22419 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22420 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22421 if (!SWIG_IsOK(ecode2)) {
22422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22423 }
22424 arg2 = static_cast< bool >(val2);
22425 if (arg1) (arg1)->m_controlDown = arg2;
22426
22427 resultobj = SWIG_Py_Void();
22428 return resultobj;
22429 fail:
22430 return NULL;
22431 }
22432
22433
22434 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22435 PyObject *resultobj = 0;
22436 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22437 bool result;
22438 void *argp1 = 0 ;
22439 int res1 = 0 ;
22440 PyObject *swig_obj[1] ;
22441
22442 if (!args) SWIG_fail;
22443 swig_obj[0] = args;
22444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22445 if (!SWIG_IsOK(res1)) {
22446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22447 }
22448 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22449 result = (bool) ((arg1)->m_controlDown);
22450 {
22451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22452 }
22453 return resultobj;
22454 fail:
22455 return NULL;
22456 }
22457
22458
22459 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22460 PyObject *resultobj = 0;
22461 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22462 bool arg2 ;
22463 void *argp1 = 0 ;
22464 int res1 = 0 ;
22465 bool val2 ;
22466 int ecode2 = 0 ;
22467 PyObject *swig_obj[2] ;
22468
22469 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22471 if (!SWIG_IsOK(res1)) {
22472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22473 }
22474 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22475 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22476 if (!SWIG_IsOK(ecode2)) {
22477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22478 }
22479 arg2 = static_cast< bool >(val2);
22480 if (arg1) (arg1)->m_shiftDown = arg2;
22481
22482 resultobj = SWIG_Py_Void();
22483 return resultobj;
22484 fail:
22485 return NULL;
22486 }
22487
22488
22489 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22490 PyObject *resultobj = 0;
22491 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22492 bool result;
22493 void *argp1 = 0 ;
22494 int res1 = 0 ;
22495 PyObject *swig_obj[1] ;
22496
22497 if (!args) SWIG_fail;
22498 swig_obj[0] = args;
22499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22500 if (!SWIG_IsOK(res1)) {
22501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22502 }
22503 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22504 result = (bool) ((arg1)->m_shiftDown);
22505 {
22506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22507 }
22508 return resultobj;
22509 fail:
22510 return NULL;
22511 }
22512
22513
22514 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22515 PyObject *resultobj = 0;
22516 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22517 bool arg2 ;
22518 void *argp1 = 0 ;
22519 int res1 = 0 ;
22520 bool val2 ;
22521 int ecode2 = 0 ;
22522 PyObject *swig_obj[2] ;
22523
22524 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22526 if (!SWIG_IsOK(res1)) {
22527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22528 }
22529 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22530 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22531 if (!SWIG_IsOK(ecode2)) {
22532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22533 }
22534 arg2 = static_cast< bool >(val2);
22535 if (arg1) (arg1)->m_altDown = arg2;
22536
22537 resultobj = SWIG_Py_Void();
22538 return resultobj;
22539 fail:
22540 return NULL;
22541 }
22542
22543
22544 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22545 PyObject *resultobj = 0;
22546 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22547 bool result;
22548 void *argp1 = 0 ;
22549 int res1 = 0 ;
22550 PyObject *swig_obj[1] ;
22551
22552 if (!args) SWIG_fail;
22553 swig_obj[0] = args;
22554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22555 if (!SWIG_IsOK(res1)) {
22556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22557 }
22558 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22559 result = (bool) ((arg1)->m_altDown);
22560 {
22561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22562 }
22563 return resultobj;
22564 fail:
22565 return NULL;
22566 }
22567
22568
22569 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22570 PyObject *resultobj = 0;
22571 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22572 bool arg2 ;
22573 void *argp1 = 0 ;
22574 int res1 = 0 ;
22575 bool val2 ;
22576 int ecode2 = 0 ;
22577 PyObject *swig_obj[2] ;
22578
22579 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22581 if (!SWIG_IsOK(res1)) {
22582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22583 }
22584 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22585 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22586 if (!SWIG_IsOK(ecode2)) {
22587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22588 }
22589 arg2 = static_cast< bool >(val2);
22590 if (arg1) (arg1)->m_metaDown = arg2;
22591
22592 resultobj = SWIG_Py_Void();
22593 return resultobj;
22594 fail:
22595 return NULL;
22596 }
22597
22598
22599 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22600 PyObject *resultobj = 0;
22601 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22602 bool result;
22603 void *argp1 = 0 ;
22604 int res1 = 0 ;
22605 PyObject *swig_obj[1] ;
22606
22607 if (!args) SWIG_fail;
22608 swig_obj[0] = args;
22609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22610 if (!SWIG_IsOK(res1)) {
22611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22612 }
22613 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22614 result = (bool) ((arg1)->m_metaDown);
22615 {
22616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22617 }
22618 return resultobj;
22619 fail:
22620 return NULL;
22621 }
22622
22623
22624 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22625 PyObject *resultobj = 0;
22626 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22627 bool arg2 ;
22628 void *argp1 = 0 ;
22629 int res1 = 0 ;
22630 bool val2 ;
22631 int ecode2 = 0 ;
22632 PyObject *swig_obj[2] ;
22633
22634 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22636 if (!SWIG_IsOK(res1)) {
22637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22638 }
22639 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22640 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22641 if (!SWIG_IsOK(ecode2)) {
22642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22643 }
22644 arg2 = static_cast< bool >(val2);
22645 if (arg1) (arg1)->m_scanCode = arg2;
22646
22647 resultobj = SWIG_Py_Void();
22648 return resultobj;
22649 fail:
22650 return NULL;
22651 }
22652
22653
22654 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22655 PyObject *resultobj = 0;
22656 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22657 bool result;
22658 void *argp1 = 0 ;
22659 int res1 = 0 ;
22660 PyObject *swig_obj[1] ;
22661
22662 if (!args) SWIG_fail;
22663 swig_obj[0] = args;
22664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22665 if (!SWIG_IsOK(res1)) {
22666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22667 }
22668 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22669 result = (bool) ((arg1)->m_scanCode);
22670 {
22671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22672 }
22673 return resultobj;
22674 fail:
22675 return NULL;
22676 }
22677
22678
22679 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22680 PyObject *resultobj = 0;
22681 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22682 unsigned int arg2 ;
22683 void *argp1 = 0 ;
22684 int res1 = 0 ;
22685 unsigned int val2 ;
22686 int ecode2 = 0 ;
22687 PyObject *swig_obj[2] ;
22688
22689 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22691 if (!SWIG_IsOK(res1)) {
22692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22693 }
22694 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22695 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22696 if (!SWIG_IsOK(ecode2)) {
22697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22698 }
22699 arg2 = static_cast< unsigned int >(val2);
22700 if (arg1) (arg1)->m_rawCode = arg2;
22701
22702 resultobj = SWIG_Py_Void();
22703 return resultobj;
22704 fail:
22705 return NULL;
22706 }
22707
22708
22709 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22710 PyObject *resultobj = 0;
22711 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22712 unsigned int result;
22713 void *argp1 = 0 ;
22714 int res1 = 0 ;
22715 PyObject *swig_obj[1] ;
22716
22717 if (!args) SWIG_fail;
22718 swig_obj[0] = args;
22719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22720 if (!SWIG_IsOK(res1)) {
22721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22722 }
22723 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22724 result = (unsigned int) ((arg1)->m_rawCode);
22725 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22726 return resultobj;
22727 fail:
22728 return NULL;
22729 }
22730
22731
22732 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22733 PyObject *resultobj = 0;
22734 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22735 unsigned int arg2 ;
22736 void *argp1 = 0 ;
22737 int res1 = 0 ;
22738 unsigned int val2 ;
22739 int ecode2 = 0 ;
22740 PyObject *swig_obj[2] ;
22741
22742 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22744 if (!SWIG_IsOK(res1)) {
22745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22746 }
22747 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22748 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22749 if (!SWIG_IsOK(ecode2)) {
22750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22751 }
22752 arg2 = static_cast< unsigned int >(val2);
22753 if (arg1) (arg1)->m_rawFlags = arg2;
22754
22755 resultobj = SWIG_Py_Void();
22756 return resultobj;
22757 fail:
22758 return NULL;
22759 }
22760
22761
22762 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22763 PyObject *resultobj = 0;
22764 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22765 unsigned int result;
22766 void *argp1 = 0 ;
22767 int res1 = 0 ;
22768 PyObject *swig_obj[1] ;
22769
22770 if (!args) SWIG_fail;
22771 swig_obj[0] = args;
22772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22773 if (!SWIG_IsOK(res1)) {
22774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22775 }
22776 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22777 result = (unsigned int) ((arg1)->m_rawFlags);
22778 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22779 return resultobj;
22780 fail:
22781 return NULL;
22782 }
22783
22784
22785 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22786 PyObject *obj;
22787 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22788 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22789 return SWIG_Py_Void();
22790 }
22791
22792 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22793 return SWIG_Python_InitShadowInstance(args);
22794 }
22795
22796 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22797 PyObject *resultobj = 0;
22798 wxSize const &arg1_defvalue = wxDefaultSize ;
22799 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22800 int arg2 = (int) 0 ;
22801 wxSizeEvent *result = 0 ;
22802 wxSize temp1 ;
22803 int val2 ;
22804 int ecode2 = 0 ;
22805 PyObject * obj0 = 0 ;
22806 PyObject * obj1 = 0 ;
22807 char * kwnames[] = {
22808 (char *) "sz",(char *) "winid", NULL
22809 };
22810
22811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22812 if (obj0) {
22813 {
22814 arg1 = &temp1;
22815 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22816 }
22817 }
22818 if (obj1) {
22819 ecode2 = SWIG_AsVal_int(obj1, &val2);
22820 if (!SWIG_IsOK(ecode2)) {
22821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22822 }
22823 arg2 = static_cast< int >(val2);
22824 }
22825 {
22826 PyThreadState* __tstate = wxPyBeginAllowThreads();
22827 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22828 wxPyEndAllowThreads(__tstate);
22829 if (PyErr_Occurred()) SWIG_fail;
22830 }
22831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22832 return resultobj;
22833 fail:
22834 return NULL;
22835 }
22836
22837
22838 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22839 PyObject *resultobj = 0;
22840 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22841 wxSize result;
22842 void *argp1 = 0 ;
22843 int res1 = 0 ;
22844 PyObject *swig_obj[1] ;
22845
22846 if (!args) SWIG_fail;
22847 swig_obj[0] = args;
22848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22849 if (!SWIG_IsOK(res1)) {
22850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22851 }
22852 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22853 {
22854 PyThreadState* __tstate = wxPyBeginAllowThreads();
22855 result = ((wxSizeEvent const *)arg1)->GetSize();
22856 wxPyEndAllowThreads(__tstate);
22857 if (PyErr_Occurred()) SWIG_fail;
22858 }
22859 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22860 return resultobj;
22861 fail:
22862 return NULL;
22863 }
22864
22865
22866 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22867 PyObject *resultobj = 0;
22868 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22869 wxRect result;
22870 void *argp1 = 0 ;
22871 int res1 = 0 ;
22872 PyObject *swig_obj[1] ;
22873
22874 if (!args) SWIG_fail;
22875 swig_obj[0] = args;
22876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22877 if (!SWIG_IsOK(res1)) {
22878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22879 }
22880 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22881 {
22882 PyThreadState* __tstate = wxPyBeginAllowThreads();
22883 result = ((wxSizeEvent const *)arg1)->GetRect();
22884 wxPyEndAllowThreads(__tstate);
22885 if (PyErr_Occurred()) SWIG_fail;
22886 }
22887 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22888 return resultobj;
22889 fail:
22890 return NULL;
22891 }
22892
22893
22894 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22895 PyObject *resultobj = 0;
22896 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22897 wxRect arg2 ;
22898 void *argp1 = 0 ;
22899 int res1 = 0 ;
22900 void *argp2 ;
22901 int res2 = 0 ;
22902 PyObject * obj0 = 0 ;
22903 PyObject * obj1 = 0 ;
22904 char * kwnames[] = {
22905 (char *) "self",(char *) "rect", NULL
22906 };
22907
22908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22910 if (!SWIG_IsOK(res1)) {
22911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22912 }
22913 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22914 {
22915 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
22916 if (!SWIG_IsOK(res2)) {
22917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22918 }
22919 if (!argp2) {
22920 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22921 } else {
22922 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
22923 arg2 = *temp;
22924 if (SWIG_IsNewObj(res2)) delete temp;
22925 }
22926 }
22927 {
22928 PyThreadState* __tstate = wxPyBeginAllowThreads();
22929 (arg1)->SetRect(arg2);
22930 wxPyEndAllowThreads(__tstate);
22931 if (PyErr_Occurred()) SWIG_fail;
22932 }
22933 resultobj = SWIG_Py_Void();
22934 return resultobj;
22935 fail:
22936 return NULL;
22937 }
22938
22939
22940 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22941 PyObject *resultobj = 0;
22942 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22943 wxSize arg2 ;
22944 void *argp1 = 0 ;
22945 int res1 = 0 ;
22946 void *argp2 ;
22947 int res2 = 0 ;
22948 PyObject * obj0 = 0 ;
22949 PyObject * obj1 = 0 ;
22950 char * kwnames[] = {
22951 (char *) "self",(char *) "size", NULL
22952 };
22953
22954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
22955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22956 if (!SWIG_IsOK(res1)) {
22957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22958 }
22959 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22960 {
22961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
22962 if (!SWIG_IsOK(res2)) {
22963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22964 }
22965 if (!argp2) {
22966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22967 } else {
22968 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
22969 arg2 = *temp;
22970 if (SWIG_IsNewObj(res2)) delete temp;
22971 }
22972 }
22973 {
22974 PyThreadState* __tstate = wxPyBeginAllowThreads();
22975 wxSizeEvent_SetSize(arg1,arg2);
22976 wxPyEndAllowThreads(__tstate);
22977 if (PyErr_Occurred()) SWIG_fail;
22978 }
22979 resultobj = SWIG_Py_Void();
22980 return resultobj;
22981 fail:
22982 return NULL;
22983 }
22984
22985
22986 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22987 PyObject *resultobj = 0;
22988 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22989 wxSize *arg2 = (wxSize *) 0 ;
22990 void *argp1 = 0 ;
22991 int res1 = 0 ;
22992 void *argp2 = 0 ;
22993 int res2 = 0 ;
22994 PyObject *swig_obj[2] ;
22995
22996 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
22997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22998 if (!SWIG_IsOK(res1)) {
22999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23000 }
23001 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23002 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23003 if (!SWIG_IsOK(res2)) {
23004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23005 }
23006 arg2 = reinterpret_cast< wxSize * >(argp2);
23007 if (arg1) (arg1)->m_size = *arg2;
23008
23009 resultobj = SWIG_Py_Void();
23010 return resultobj;
23011 fail:
23012 return NULL;
23013 }
23014
23015
23016 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23017 PyObject *resultobj = 0;
23018 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23019 wxSize *result = 0 ;
23020 void *argp1 = 0 ;
23021 int res1 = 0 ;
23022 PyObject *swig_obj[1] ;
23023
23024 if (!args) SWIG_fail;
23025 swig_obj[0] = args;
23026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23027 if (!SWIG_IsOK(res1)) {
23028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23029 }
23030 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23031 result = (wxSize *)& ((arg1)->m_size);
23032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23033 return resultobj;
23034 fail:
23035 return NULL;
23036 }
23037
23038
23039 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23040 PyObject *resultobj = 0;
23041 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23042 wxRect *arg2 = (wxRect *) 0 ;
23043 void *argp1 = 0 ;
23044 int res1 = 0 ;
23045 void *argp2 = 0 ;
23046 int res2 = 0 ;
23047 PyObject *swig_obj[2] ;
23048
23049 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23051 if (!SWIG_IsOK(res1)) {
23052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23053 }
23054 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23055 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23056 if (!SWIG_IsOK(res2)) {
23057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23058 }
23059 arg2 = reinterpret_cast< wxRect * >(argp2);
23060 if (arg1) (arg1)->m_rect = *arg2;
23061
23062 resultobj = SWIG_Py_Void();
23063 return resultobj;
23064 fail:
23065 return NULL;
23066 }
23067
23068
23069 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23070 PyObject *resultobj = 0;
23071 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23072 wxRect *result = 0 ;
23073 void *argp1 = 0 ;
23074 int res1 = 0 ;
23075 PyObject *swig_obj[1] ;
23076
23077 if (!args) SWIG_fail;
23078 swig_obj[0] = args;
23079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23080 if (!SWIG_IsOK(res1)) {
23081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23082 }
23083 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23084 result = (wxRect *)& ((arg1)->m_rect);
23085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23086 return resultobj;
23087 fail:
23088 return NULL;
23089 }
23090
23091
23092 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23093 PyObject *obj;
23094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23095 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23096 return SWIG_Py_Void();
23097 }
23098
23099 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23100 return SWIG_Python_InitShadowInstance(args);
23101 }
23102
23103 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23104 PyObject *resultobj = 0;
23105 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23106 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23107 int arg2 = (int) 0 ;
23108 wxMoveEvent *result = 0 ;
23109 wxPoint temp1 ;
23110 int val2 ;
23111 int ecode2 = 0 ;
23112 PyObject * obj0 = 0 ;
23113 PyObject * obj1 = 0 ;
23114 char * kwnames[] = {
23115 (char *) "pos",(char *) "winid", NULL
23116 };
23117
23118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23119 if (obj0) {
23120 {
23121 arg1 = &temp1;
23122 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23123 }
23124 }
23125 if (obj1) {
23126 ecode2 = SWIG_AsVal_int(obj1, &val2);
23127 if (!SWIG_IsOK(ecode2)) {
23128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23129 }
23130 arg2 = static_cast< int >(val2);
23131 }
23132 {
23133 PyThreadState* __tstate = wxPyBeginAllowThreads();
23134 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23135 wxPyEndAllowThreads(__tstate);
23136 if (PyErr_Occurred()) SWIG_fail;
23137 }
23138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23139 return resultobj;
23140 fail:
23141 return NULL;
23142 }
23143
23144
23145 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23146 PyObject *resultobj = 0;
23147 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23148 wxPoint result;
23149 void *argp1 = 0 ;
23150 int res1 = 0 ;
23151 PyObject *swig_obj[1] ;
23152
23153 if (!args) SWIG_fail;
23154 swig_obj[0] = args;
23155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23156 if (!SWIG_IsOK(res1)) {
23157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23158 }
23159 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23160 {
23161 PyThreadState* __tstate = wxPyBeginAllowThreads();
23162 result = ((wxMoveEvent const *)arg1)->GetPosition();
23163 wxPyEndAllowThreads(__tstate);
23164 if (PyErr_Occurred()) SWIG_fail;
23165 }
23166 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23167 return resultobj;
23168 fail:
23169 return NULL;
23170 }
23171
23172
23173 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23174 PyObject *resultobj = 0;
23175 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23176 wxRect result;
23177 void *argp1 = 0 ;
23178 int res1 = 0 ;
23179 PyObject *swig_obj[1] ;
23180
23181 if (!args) SWIG_fail;
23182 swig_obj[0] = args;
23183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23184 if (!SWIG_IsOK(res1)) {
23185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23186 }
23187 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23188 {
23189 PyThreadState* __tstate = wxPyBeginAllowThreads();
23190 result = ((wxMoveEvent const *)arg1)->GetRect();
23191 wxPyEndAllowThreads(__tstate);
23192 if (PyErr_Occurred()) SWIG_fail;
23193 }
23194 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23195 return resultobj;
23196 fail:
23197 return NULL;
23198 }
23199
23200
23201 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23202 PyObject *resultobj = 0;
23203 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23204 wxRect *arg2 = 0 ;
23205 void *argp1 = 0 ;
23206 int res1 = 0 ;
23207 wxRect temp2 ;
23208 PyObject * obj0 = 0 ;
23209 PyObject * obj1 = 0 ;
23210 char * kwnames[] = {
23211 (char *) "self",(char *) "rect", NULL
23212 };
23213
23214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23216 if (!SWIG_IsOK(res1)) {
23217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23218 }
23219 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23220 {
23221 arg2 = &temp2;
23222 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23223 }
23224 {
23225 PyThreadState* __tstate = wxPyBeginAllowThreads();
23226 (arg1)->SetRect((wxRect const &)*arg2);
23227 wxPyEndAllowThreads(__tstate);
23228 if (PyErr_Occurred()) SWIG_fail;
23229 }
23230 resultobj = SWIG_Py_Void();
23231 return resultobj;
23232 fail:
23233 return NULL;
23234 }
23235
23236
23237 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23238 PyObject *resultobj = 0;
23239 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23240 wxPoint *arg2 = 0 ;
23241 void *argp1 = 0 ;
23242 int res1 = 0 ;
23243 wxPoint temp2 ;
23244 PyObject * obj0 = 0 ;
23245 PyObject * obj1 = 0 ;
23246 char * kwnames[] = {
23247 (char *) "self",(char *) "pos", NULL
23248 };
23249
23250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23252 if (!SWIG_IsOK(res1)) {
23253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23254 }
23255 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23256 {
23257 arg2 = &temp2;
23258 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23259 }
23260 {
23261 PyThreadState* __tstate = wxPyBeginAllowThreads();
23262 (arg1)->SetPosition((wxPoint const &)*arg2);
23263 wxPyEndAllowThreads(__tstate);
23264 if (PyErr_Occurred()) SWIG_fail;
23265 }
23266 resultobj = SWIG_Py_Void();
23267 return resultobj;
23268 fail:
23269 return NULL;
23270 }
23271
23272
23273 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23274 PyObject *obj;
23275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23276 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23277 return SWIG_Py_Void();
23278 }
23279
23280 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23281 return SWIG_Python_InitShadowInstance(args);
23282 }
23283
23284 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23285 PyObject *resultobj = 0;
23286 int arg1 = (int) 0 ;
23287 wxPaintEvent *result = 0 ;
23288 int val1 ;
23289 int ecode1 = 0 ;
23290 PyObject * obj0 = 0 ;
23291 char * kwnames[] = {
23292 (char *) "Id", NULL
23293 };
23294
23295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23296 if (obj0) {
23297 ecode1 = SWIG_AsVal_int(obj0, &val1);
23298 if (!SWIG_IsOK(ecode1)) {
23299 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23300 }
23301 arg1 = static_cast< int >(val1);
23302 }
23303 {
23304 PyThreadState* __tstate = wxPyBeginAllowThreads();
23305 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23306 wxPyEndAllowThreads(__tstate);
23307 if (PyErr_Occurred()) SWIG_fail;
23308 }
23309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23310 return resultobj;
23311 fail:
23312 return NULL;
23313 }
23314
23315
23316 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23317 PyObject *obj;
23318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23319 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23320 return SWIG_Py_Void();
23321 }
23322
23323 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23324 return SWIG_Python_InitShadowInstance(args);
23325 }
23326
23327 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23328 PyObject *resultobj = 0;
23329 int arg1 = (int) 0 ;
23330 wxNcPaintEvent *result = 0 ;
23331 int val1 ;
23332 int ecode1 = 0 ;
23333 PyObject * obj0 = 0 ;
23334 char * kwnames[] = {
23335 (char *) "winid", NULL
23336 };
23337
23338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23339 if (obj0) {
23340 ecode1 = SWIG_AsVal_int(obj0, &val1);
23341 if (!SWIG_IsOK(ecode1)) {
23342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23343 }
23344 arg1 = static_cast< int >(val1);
23345 }
23346 {
23347 PyThreadState* __tstate = wxPyBeginAllowThreads();
23348 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23349 wxPyEndAllowThreads(__tstate);
23350 if (PyErr_Occurred()) SWIG_fail;
23351 }
23352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23353 return resultobj;
23354 fail:
23355 return NULL;
23356 }
23357
23358
23359 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23360 PyObject *obj;
23361 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23362 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23363 return SWIG_Py_Void();
23364 }
23365
23366 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23367 return SWIG_Python_InitShadowInstance(args);
23368 }
23369
23370 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23371 PyObject *resultobj = 0;
23372 int arg1 = (int) 0 ;
23373 wxDC *arg2 = (wxDC *) NULL ;
23374 wxEraseEvent *result = 0 ;
23375 int val1 ;
23376 int ecode1 = 0 ;
23377 void *argp2 = 0 ;
23378 int res2 = 0 ;
23379 PyObject * obj0 = 0 ;
23380 PyObject * obj1 = 0 ;
23381 char * kwnames[] = {
23382 (char *) "Id",(char *) "dc", NULL
23383 };
23384
23385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23386 if (obj0) {
23387 ecode1 = SWIG_AsVal_int(obj0, &val1);
23388 if (!SWIG_IsOK(ecode1)) {
23389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23390 }
23391 arg1 = static_cast< int >(val1);
23392 }
23393 if (obj1) {
23394 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23395 if (!SWIG_IsOK(res2)) {
23396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23397 }
23398 arg2 = reinterpret_cast< wxDC * >(argp2);
23399 }
23400 {
23401 PyThreadState* __tstate = wxPyBeginAllowThreads();
23402 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23403 wxPyEndAllowThreads(__tstate);
23404 if (PyErr_Occurred()) SWIG_fail;
23405 }
23406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23407 return resultobj;
23408 fail:
23409 return NULL;
23410 }
23411
23412
23413 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23414 PyObject *resultobj = 0;
23415 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23416 wxDC *result = 0 ;
23417 void *argp1 = 0 ;
23418 int res1 = 0 ;
23419 PyObject *swig_obj[1] ;
23420
23421 if (!args) SWIG_fail;
23422 swig_obj[0] = args;
23423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23424 if (!SWIG_IsOK(res1)) {
23425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23426 }
23427 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23428 {
23429 PyThreadState* __tstate = wxPyBeginAllowThreads();
23430 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23431 wxPyEndAllowThreads(__tstate);
23432 if (PyErr_Occurred()) SWIG_fail;
23433 }
23434 {
23435 resultobj = wxPyMake_wxObject(result, (bool)0);
23436 }
23437 return resultobj;
23438 fail:
23439 return NULL;
23440 }
23441
23442
23443 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23444 PyObject *obj;
23445 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23446 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23447 return SWIG_Py_Void();
23448 }
23449
23450 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23451 return SWIG_Python_InitShadowInstance(args);
23452 }
23453
23454 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23455 PyObject *resultobj = 0;
23456 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23457 int arg2 = (int) 0 ;
23458 wxFocusEvent *result = 0 ;
23459 int val1 ;
23460 int ecode1 = 0 ;
23461 int val2 ;
23462 int ecode2 = 0 ;
23463 PyObject * obj0 = 0 ;
23464 PyObject * obj1 = 0 ;
23465 char * kwnames[] = {
23466 (char *) "type",(char *) "winid", NULL
23467 };
23468
23469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23470 if (obj0) {
23471 ecode1 = SWIG_AsVal_int(obj0, &val1);
23472 if (!SWIG_IsOK(ecode1)) {
23473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23474 }
23475 arg1 = static_cast< wxEventType >(val1);
23476 }
23477 if (obj1) {
23478 ecode2 = SWIG_AsVal_int(obj1, &val2);
23479 if (!SWIG_IsOK(ecode2)) {
23480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23481 }
23482 arg2 = static_cast< int >(val2);
23483 }
23484 {
23485 PyThreadState* __tstate = wxPyBeginAllowThreads();
23486 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23487 wxPyEndAllowThreads(__tstate);
23488 if (PyErr_Occurred()) SWIG_fail;
23489 }
23490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23491 return resultobj;
23492 fail:
23493 return NULL;
23494 }
23495
23496
23497 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23498 PyObject *resultobj = 0;
23499 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23500 wxWindow *result = 0 ;
23501 void *argp1 = 0 ;
23502 int res1 = 0 ;
23503 PyObject *swig_obj[1] ;
23504
23505 if (!args) SWIG_fail;
23506 swig_obj[0] = args;
23507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23508 if (!SWIG_IsOK(res1)) {
23509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23510 }
23511 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23512 {
23513 PyThreadState* __tstate = wxPyBeginAllowThreads();
23514 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23515 wxPyEndAllowThreads(__tstate);
23516 if (PyErr_Occurred()) SWIG_fail;
23517 }
23518 {
23519 resultobj = wxPyMake_wxObject(result, (bool)0);
23520 }
23521 return resultobj;
23522 fail:
23523 return NULL;
23524 }
23525
23526
23527 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23528 PyObject *resultobj = 0;
23529 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23530 wxWindow *arg2 = (wxWindow *) 0 ;
23531 void *argp1 = 0 ;
23532 int res1 = 0 ;
23533 void *argp2 = 0 ;
23534 int res2 = 0 ;
23535 PyObject * obj0 = 0 ;
23536 PyObject * obj1 = 0 ;
23537 char * kwnames[] = {
23538 (char *) "self",(char *) "win", NULL
23539 };
23540
23541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23543 if (!SWIG_IsOK(res1)) {
23544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23545 }
23546 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23548 if (!SWIG_IsOK(res2)) {
23549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23550 }
23551 arg2 = reinterpret_cast< wxWindow * >(argp2);
23552 {
23553 PyThreadState* __tstate = wxPyBeginAllowThreads();
23554 (arg1)->SetWindow(arg2);
23555 wxPyEndAllowThreads(__tstate);
23556 if (PyErr_Occurred()) SWIG_fail;
23557 }
23558 resultobj = SWIG_Py_Void();
23559 return resultobj;
23560 fail:
23561 return NULL;
23562 }
23563
23564
23565 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23566 PyObject *obj;
23567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23568 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23569 return SWIG_Py_Void();
23570 }
23571
23572 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23573 return SWIG_Python_InitShadowInstance(args);
23574 }
23575
23576 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23577 PyObject *resultobj = 0;
23578 wxWindow *arg1 = (wxWindow *) NULL ;
23579 wxChildFocusEvent *result = 0 ;
23580 void *argp1 = 0 ;
23581 int res1 = 0 ;
23582 PyObject * obj0 = 0 ;
23583 char * kwnames[] = {
23584 (char *) "win", NULL
23585 };
23586
23587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23588 if (obj0) {
23589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23590 if (!SWIG_IsOK(res1)) {
23591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23592 }
23593 arg1 = reinterpret_cast< wxWindow * >(argp1);
23594 }
23595 {
23596 PyThreadState* __tstate = wxPyBeginAllowThreads();
23597 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23598 wxPyEndAllowThreads(__tstate);
23599 if (PyErr_Occurred()) SWIG_fail;
23600 }
23601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23602 return resultobj;
23603 fail:
23604 return NULL;
23605 }
23606
23607
23608 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23609 PyObject *resultobj = 0;
23610 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23611 wxWindow *result = 0 ;
23612 void *argp1 = 0 ;
23613 int res1 = 0 ;
23614 PyObject *swig_obj[1] ;
23615
23616 if (!args) SWIG_fail;
23617 swig_obj[0] = args;
23618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23619 if (!SWIG_IsOK(res1)) {
23620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23621 }
23622 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23623 {
23624 PyThreadState* __tstate = wxPyBeginAllowThreads();
23625 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23626 wxPyEndAllowThreads(__tstate);
23627 if (PyErr_Occurred()) SWIG_fail;
23628 }
23629 {
23630 resultobj = wxPyMake_wxObject(result, (bool)0);
23631 }
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23639 PyObject *obj;
23640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23641 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23642 return SWIG_Py_Void();
23643 }
23644
23645 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23646 return SWIG_Python_InitShadowInstance(args);
23647 }
23648
23649 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23650 PyObject *resultobj = 0;
23651 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23652 bool arg2 = (bool) true ;
23653 int arg3 = (int) 0 ;
23654 wxActivateEvent *result = 0 ;
23655 int val1 ;
23656 int ecode1 = 0 ;
23657 bool val2 ;
23658 int ecode2 = 0 ;
23659 int val3 ;
23660 int ecode3 = 0 ;
23661 PyObject * obj0 = 0 ;
23662 PyObject * obj1 = 0 ;
23663 PyObject * obj2 = 0 ;
23664 char * kwnames[] = {
23665 (char *) "type",(char *) "active",(char *) "Id", NULL
23666 };
23667
23668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23669 if (obj0) {
23670 ecode1 = SWIG_AsVal_int(obj0, &val1);
23671 if (!SWIG_IsOK(ecode1)) {
23672 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23673 }
23674 arg1 = static_cast< wxEventType >(val1);
23675 }
23676 if (obj1) {
23677 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23678 if (!SWIG_IsOK(ecode2)) {
23679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23680 }
23681 arg2 = static_cast< bool >(val2);
23682 }
23683 if (obj2) {
23684 ecode3 = SWIG_AsVal_int(obj2, &val3);
23685 if (!SWIG_IsOK(ecode3)) {
23686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23687 }
23688 arg3 = static_cast< int >(val3);
23689 }
23690 {
23691 PyThreadState* __tstate = wxPyBeginAllowThreads();
23692 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23693 wxPyEndAllowThreads(__tstate);
23694 if (PyErr_Occurred()) SWIG_fail;
23695 }
23696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23697 return resultobj;
23698 fail:
23699 return NULL;
23700 }
23701
23702
23703 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23704 PyObject *resultobj = 0;
23705 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23706 bool result;
23707 void *argp1 = 0 ;
23708 int res1 = 0 ;
23709 PyObject *swig_obj[1] ;
23710
23711 if (!args) SWIG_fail;
23712 swig_obj[0] = args;
23713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23714 if (!SWIG_IsOK(res1)) {
23715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23716 }
23717 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23718 {
23719 PyThreadState* __tstate = wxPyBeginAllowThreads();
23720 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23721 wxPyEndAllowThreads(__tstate);
23722 if (PyErr_Occurred()) SWIG_fail;
23723 }
23724 {
23725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23726 }
23727 return resultobj;
23728 fail:
23729 return NULL;
23730 }
23731
23732
23733 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23734 PyObject *obj;
23735 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23736 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23737 return SWIG_Py_Void();
23738 }
23739
23740 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23741 return SWIG_Python_InitShadowInstance(args);
23742 }
23743
23744 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23745 PyObject *resultobj = 0;
23746 int arg1 = (int) 0 ;
23747 wxInitDialogEvent *result = 0 ;
23748 int val1 ;
23749 int ecode1 = 0 ;
23750 PyObject * obj0 = 0 ;
23751 char * kwnames[] = {
23752 (char *) "Id", NULL
23753 };
23754
23755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23756 if (obj0) {
23757 ecode1 = SWIG_AsVal_int(obj0, &val1);
23758 if (!SWIG_IsOK(ecode1)) {
23759 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23760 }
23761 arg1 = static_cast< int >(val1);
23762 }
23763 {
23764 PyThreadState* __tstate = wxPyBeginAllowThreads();
23765 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23766 wxPyEndAllowThreads(__tstate);
23767 if (PyErr_Occurred()) SWIG_fail;
23768 }
23769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23770 return resultobj;
23771 fail:
23772 return NULL;
23773 }
23774
23775
23776 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23777 PyObject *obj;
23778 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23779 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23780 return SWIG_Py_Void();
23781 }
23782
23783 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23784 return SWIG_Python_InitShadowInstance(args);
23785 }
23786
23787 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23788 PyObject *resultobj = 0;
23789 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23790 int arg2 = (int) 0 ;
23791 wxMenu *arg3 = (wxMenu *) NULL ;
23792 wxMenuEvent *result = 0 ;
23793 int val1 ;
23794 int ecode1 = 0 ;
23795 int val2 ;
23796 int ecode2 = 0 ;
23797 void *argp3 = 0 ;
23798 int res3 = 0 ;
23799 PyObject * obj0 = 0 ;
23800 PyObject * obj1 = 0 ;
23801 PyObject * obj2 = 0 ;
23802 char * kwnames[] = {
23803 (char *) "type",(char *) "winid",(char *) "menu", NULL
23804 };
23805
23806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23807 if (obj0) {
23808 ecode1 = SWIG_AsVal_int(obj0, &val1);
23809 if (!SWIG_IsOK(ecode1)) {
23810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23811 }
23812 arg1 = static_cast< wxEventType >(val1);
23813 }
23814 if (obj1) {
23815 ecode2 = SWIG_AsVal_int(obj1, &val2);
23816 if (!SWIG_IsOK(ecode2)) {
23817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23818 }
23819 arg2 = static_cast< int >(val2);
23820 }
23821 if (obj2) {
23822 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23823 if (!SWIG_IsOK(res3)) {
23824 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23825 }
23826 arg3 = reinterpret_cast< wxMenu * >(argp3);
23827 }
23828 {
23829 PyThreadState* __tstate = wxPyBeginAllowThreads();
23830 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23831 wxPyEndAllowThreads(__tstate);
23832 if (PyErr_Occurred()) SWIG_fail;
23833 }
23834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23835 return resultobj;
23836 fail:
23837 return NULL;
23838 }
23839
23840
23841 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23842 PyObject *resultobj = 0;
23843 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23844 int result;
23845 void *argp1 = 0 ;
23846 int res1 = 0 ;
23847 PyObject *swig_obj[1] ;
23848
23849 if (!args) SWIG_fail;
23850 swig_obj[0] = args;
23851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23852 if (!SWIG_IsOK(res1)) {
23853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23854 }
23855 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23856 {
23857 PyThreadState* __tstate = wxPyBeginAllowThreads();
23858 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23859 wxPyEndAllowThreads(__tstate);
23860 if (PyErr_Occurred()) SWIG_fail;
23861 }
23862 resultobj = SWIG_From_int(static_cast< int >(result));
23863 return resultobj;
23864 fail:
23865 return NULL;
23866 }
23867
23868
23869 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23870 PyObject *resultobj = 0;
23871 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23872 bool result;
23873 void *argp1 = 0 ;
23874 int res1 = 0 ;
23875 PyObject *swig_obj[1] ;
23876
23877 if (!args) SWIG_fail;
23878 swig_obj[0] = args;
23879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23880 if (!SWIG_IsOK(res1)) {
23881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23882 }
23883 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23884 {
23885 PyThreadState* __tstate = wxPyBeginAllowThreads();
23886 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23887 wxPyEndAllowThreads(__tstate);
23888 if (PyErr_Occurred()) SWIG_fail;
23889 }
23890 {
23891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23892 }
23893 return resultobj;
23894 fail:
23895 return NULL;
23896 }
23897
23898
23899 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23900 PyObject *resultobj = 0;
23901 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23902 wxMenu *result = 0 ;
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_wxMenuEvent, 0 | 0 );
23910 if (!SWIG_IsOK(res1)) {
23911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23912 }
23913 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23914 {
23915 PyThreadState* __tstate = wxPyBeginAllowThreads();
23916 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
23917 wxPyEndAllowThreads(__tstate);
23918 if (PyErr_Occurred()) SWIG_fail;
23919 }
23920 {
23921 resultobj = wxPyMake_wxObject(result, (bool)0);
23922 }
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 SWIGINTERN PyObject *MenuEvent_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_wxMenuEvent, SWIG_NewClientData(obj));
23933 return SWIG_Py_Void();
23934 }
23935
23936 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23937 return SWIG_Python_InitShadowInstance(args);
23938 }
23939
23940 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23941 PyObject *resultobj = 0;
23942 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23943 int arg2 = (int) 0 ;
23944 wxCloseEvent *result = 0 ;
23945 int val1 ;
23946 int ecode1 = 0 ;
23947 int val2 ;
23948 int ecode2 = 0 ;
23949 PyObject * obj0 = 0 ;
23950 PyObject * obj1 = 0 ;
23951 char * kwnames[] = {
23952 (char *) "type",(char *) "winid", NULL
23953 };
23954
23955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23956 if (obj0) {
23957 ecode1 = SWIG_AsVal_int(obj0, &val1);
23958 if (!SWIG_IsOK(ecode1)) {
23959 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23960 }
23961 arg1 = static_cast< wxEventType >(val1);
23962 }
23963 if (obj1) {
23964 ecode2 = SWIG_AsVal_int(obj1, &val2);
23965 if (!SWIG_IsOK(ecode2)) {
23966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
23967 }
23968 arg2 = static_cast< int >(val2);
23969 }
23970 {
23971 PyThreadState* __tstate = wxPyBeginAllowThreads();
23972 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
23973 wxPyEndAllowThreads(__tstate);
23974 if (PyErr_Occurred()) SWIG_fail;
23975 }
23976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
23977 return resultobj;
23978 fail:
23979 return NULL;
23980 }
23981
23982
23983 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23984 PyObject *resultobj = 0;
23985 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
23986 bool arg2 ;
23987 void *argp1 = 0 ;
23988 int res1 = 0 ;
23989 bool val2 ;
23990 int ecode2 = 0 ;
23991 PyObject * obj0 = 0 ;
23992 PyObject * obj1 = 0 ;
23993 char * kwnames[] = {
23994 (char *) "self",(char *) "logOff", NULL
23995 };
23996
23997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
23998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
23999 if (!SWIG_IsOK(res1)) {
24000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24001 }
24002 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24003 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24004 if (!SWIG_IsOK(ecode2)) {
24005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24006 }
24007 arg2 = static_cast< bool >(val2);
24008 {
24009 PyThreadState* __tstate = wxPyBeginAllowThreads();
24010 (arg1)->SetLoggingOff(arg2);
24011 wxPyEndAllowThreads(__tstate);
24012 if (PyErr_Occurred()) SWIG_fail;
24013 }
24014 resultobj = SWIG_Py_Void();
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 PyObject *resultobj = 0;
24023 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24024 bool result;
24025 void *argp1 = 0 ;
24026 int res1 = 0 ;
24027 PyObject *swig_obj[1] ;
24028
24029 if (!args) SWIG_fail;
24030 swig_obj[0] = args;
24031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24032 if (!SWIG_IsOK(res1)) {
24033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24034 }
24035 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24036 {
24037 PyThreadState* __tstate = wxPyBeginAllowThreads();
24038 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24039 wxPyEndAllowThreads(__tstate);
24040 if (PyErr_Occurred()) SWIG_fail;
24041 }
24042 {
24043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24044 }
24045 return resultobj;
24046 fail:
24047 return NULL;
24048 }
24049
24050
24051 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24052 PyObject *resultobj = 0;
24053 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24054 bool arg2 = (bool) true ;
24055 void *argp1 = 0 ;
24056 int res1 = 0 ;
24057 bool val2 ;
24058 int ecode2 = 0 ;
24059 PyObject * obj0 = 0 ;
24060 PyObject * obj1 = 0 ;
24061 char * kwnames[] = {
24062 (char *) "self",(char *) "veto", NULL
24063 };
24064
24065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24067 if (!SWIG_IsOK(res1)) {
24068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24069 }
24070 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24071 if (obj1) {
24072 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24073 if (!SWIG_IsOK(ecode2)) {
24074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24075 }
24076 arg2 = static_cast< bool >(val2);
24077 }
24078 {
24079 PyThreadState* __tstate = wxPyBeginAllowThreads();
24080 (arg1)->Veto(arg2);
24081 wxPyEndAllowThreads(__tstate);
24082 if (PyErr_Occurred()) SWIG_fail;
24083 }
24084 resultobj = SWIG_Py_Void();
24085 return resultobj;
24086 fail:
24087 return NULL;
24088 }
24089
24090
24091 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24092 PyObject *resultobj = 0;
24093 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24094 bool result;
24095 void *argp1 = 0 ;
24096 int res1 = 0 ;
24097 PyObject *swig_obj[1] ;
24098
24099 if (!args) SWIG_fail;
24100 swig_obj[0] = args;
24101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24102 if (!SWIG_IsOK(res1)) {
24103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24104 }
24105 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24106 {
24107 PyThreadState* __tstate = wxPyBeginAllowThreads();
24108 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24109 wxPyEndAllowThreads(__tstate);
24110 if (PyErr_Occurred()) SWIG_fail;
24111 }
24112 {
24113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24114 }
24115 return resultobj;
24116 fail:
24117 return NULL;
24118 }
24119
24120
24121 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24122 PyObject *resultobj = 0;
24123 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24124 bool arg2 ;
24125 void *argp1 = 0 ;
24126 int res1 = 0 ;
24127 bool val2 ;
24128 int ecode2 = 0 ;
24129 PyObject * obj0 = 0 ;
24130 PyObject * obj1 = 0 ;
24131 char * kwnames[] = {
24132 (char *) "self",(char *) "canVeto", NULL
24133 };
24134
24135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24137 if (!SWIG_IsOK(res1)) {
24138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24139 }
24140 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24141 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24142 if (!SWIG_IsOK(ecode2)) {
24143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24144 }
24145 arg2 = static_cast< bool >(val2);
24146 {
24147 PyThreadState* __tstate = wxPyBeginAllowThreads();
24148 (arg1)->SetCanVeto(arg2);
24149 wxPyEndAllowThreads(__tstate);
24150 if (PyErr_Occurred()) SWIG_fail;
24151 }
24152 resultobj = SWIG_Py_Void();
24153 return resultobj;
24154 fail:
24155 return NULL;
24156 }
24157
24158
24159 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24160 PyObject *resultobj = 0;
24161 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24162 bool result;
24163 void *argp1 = 0 ;
24164 int res1 = 0 ;
24165 PyObject *swig_obj[1] ;
24166
24167 if (!args) SWIG_fail;
24168 swig_obj[0] = args;
24169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24170 if (!SWIG_IsOK(res1)) {
24171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24172 }
24173 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24174 {
24175 PyThreadState* __tstate = wxPyBeginAllowThreads();
24176 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24177 wxPyEndAllowThreads(__tstate);
24178 if (PyErr_Occurred()) SWIG_fail;
24179 }
24180 {
24181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24182 }
24183 return resultobj;
24184 fail:
24185 return NULL;
24186 }
24187
24188
24189 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24190 PyObject *obj;
24191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24192 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24193 return SWIG_Py_Void();
24194 }
24195
24196 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24197 return SWIG_Python_InitShadowInstance(args);
24198 }
24199
24200 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24201 PyObject *resultobj = 0;
24202 int arg1 = (int) 0 ;
24203 bool arg2 = (bool) false ;
24204 wxShowEvent *result = 0 ;
24205 int val1 ;
24206 int ecode1 = 0 ;
24207 bool val2 ;
24208 int ecode2 = 0 ;
24209 PyObject * obj0 = 0 ;
24210 PyObject * obj1 = 0 ;
24211 char * kwnames[] = {
24212 (char *) "winid",(char *) "show", NULL
24213 };
24214
24215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24216 if (obj0) {
24217 ecode1 = SWIG_AsVal_int(obj0, &val1);
24218 if (!SWIG_IsOK(ecode1)) {
24219 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24220 }
24221 arg1 = static_cast< int >(val1);
24222 }
24223 if (obj1) {
24224 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24225 if (!SWIG_IsOK(ecode2)) {
24226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24227 }
24228 arg2 = static_cast< bool >(val2);
24229 }
24230 {
24231 PyThreadState* __tstate = wxPyBeginAllowThreads();
24232 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24233 wxPyEndAllowThreads(__tstate);
24234 if (PyErr_Occurred()) SWIG_fail;
24235 }
24236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24237 return resultobj;
24238 fail:
24239 return NULL;
24240 }
24241
24242
24243 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24244 PyObject *resultobj = 0;
24245 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24246 bool arg2 ;
24247 void *argp1 = 0 ;
24248 int res1 = 0 ;
24249 bool val2 ;
24250 int ecode2 = 0 ;
24251 PyObject * obj0 = 0 ;
24252 PyObject * obj1 = 0 ;
24253 char * kwnames[] = {
24254 (char *) "self",(char *) "show", NULL
24255 };
24256
24257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24259 if (!SWIG_IsOK(res1)) {
24260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24261 }
24262 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24263 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24264 if (!SWIG_IsOK(ecode2)) {
24265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24266 }
24267 arg2 = static_cast< bool >(val2);
24268 {
24269 PyThreadState* __tstate = wxPyBeginAllowThreads();
24270 (arg1)->SetShow(arg2);
24271 wxPyEndAllowThreads(__tstate);
24272 if (PyErr_Occurred()) SWIG_fail;
24273 }
24274 resultobj = SWIG_Py_Void();
24275 return resultobj;
24276 fail:
24277 return NULL;
24278 }
24279
24280
24281 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24282 PyObject *resultobj = 0;
24283 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24284 bool result;
24285 void *argp1 = 0 ;
24286 int res1 = 0 ;
24287 PyObject *swig_obj[1] ;
24288
24289 if (!args) SWIG_fail;
24290 swig_obj[0] = args;
24291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24292 if (!SWIG_IsOK(res1)) {
24293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24294 }
24295 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24296 {
24297 PyThreadState* __tstate = wxPyBeginAllowThreads();
24298 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24299 wxPyEndAllowThreads(__tstate);
24300 if (PyErr_Occurred()) SWIG_fail;
24301 }
24302 {
24303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24304 }
24305 return resultobj;
24306 fail:
24307 return NULL;
24308 }
24309
24310
24311 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24312 PyObject *obj;
24313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24314 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24315 return SWIG_Py_Void();
24316 }
24317
24318 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24319 return SWIG_Python_InitShadowInstance(args);
24320 }
24321
24322 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24323 PyObject *resultobj = 0;
24324 int arg1 = (int) 0 ;
24325 bool arg2 = (bool) true ;
24326 wxIconizeEvent *result = 0 ;
24327 int val1 ;
24328 int ecode1 = 0 ;
24329 bool val2 ;
24330 int ecode2 = 0 ;
24331 PyObject * obj0 = 0 ;
24332 PyObject * obj1 = 0 ;
24333 char * kwnames[] = {
24334 (char *) "id",(char *) "iconized", NULL
24335 };
24336
24337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24338 if (obj0) {
24339 ecode1 = SWIG_AsVal_int(obj0, &val1);
24340 if (!SWIG_IsOK(ecode1)) {
24341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24342 }
24343 arg1 = static_cast< int >(val1);
24344 }
24345 if (obj1) {
24346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24347 if (!SWIG_IsOK(ecode2)) {
24348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24349 }
24350 arg2 = static_cast< bool >(val2);
24351 }
24352 {
24353 PyThreadState* __tstate = wxPyBeginAllowThreads();
24354 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24355 wxPyEndAllowThreads(__tstate);
24356 if (PyErr_Occurred()) SWIG_fail;
24357 }
24358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24359 return resultobj;
24360 fail:
24361 return NULL;
24362 }
24363
24364
24365 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24366 PyObject *resultobj = 0;
24367 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24368 bool result;
24369 void *argp1 = 0 ;
24370 int res1 = 0 ;
24371 PyObject *swig_obj[1] ;
24372
24373 if (!args) SWIG_fail;
24374 swig_obj[0] = args;
24375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24376 if (!SWIG_IsOK(res1)) {
24377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24378 }
24379 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24380 {
24381 PyThreadState* __tstate = wxPyBeginAllowThreads();
24382 result = (bool)(arg1)->Iconized();
24383 wxPyEndAllowThreads(__tstate);
24384 if (PyErr_Occurred()) SWIG_fail;
24385 }
24386 {
24387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24388 }
24389 return resultobj;
24390 fail:
24391 return NULL;
24392 }
24393
24394
24395 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24396 PyObject *obj;
24397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24398 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24399 return SWIG_Py_Void();
24400 }
24401
24402 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24403 return SWIG_Python_InitShadowInstance(args);
24404 }
24405
24406 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24407 PyObject *resultobj = 0;
24408 int arg1 = (int) 0 ;
24409 wxMaximizeEvent *result = 0 ;
24410 int val1 ;
24411 int ecode1 = 0 ;
24412 PyObject * obj0 = 0 ;
24413 char * kwnames[] = {
24414 (char *) "id", NULL
24415 };
24416
24417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24418 if (obj0) {
24419 ecode1 = SWIG_AsVal_int(obj0, &val1);
24420 if (!SWIG_IsOK(ecode1)) {
24421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24422 }
24423 arg1 = static_cast< int >(val1);
24424 }
24425 {
24426 PyThreadState* __tstate = wxPyBeginAllowThreads();
24427 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24428 wxPyEndAllowThreads(__tstate);
24429 if (PyErr_Occurred()) SWIG_fail;
24430 }
24431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24432 return resultobj;
24433 fail:
24434 return NULL;
24435 }
24436
24437
24438 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24439 PyObject *obj;
24440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24441 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24442 return SWIG_Py_Void();
24443 }
24444
24445 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24446 return SWIG_Python_InitShadowInstance(args);
24447 }
24448
24449 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24450 PyObject *resultobj = 0;
24451 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24452 wxPoint result;
24453 void *argp1 = 0 ;
24454 int res1 = 0 ;
24455 PyObject *swig_obj[1] ;
24456
24457 if (!args) SWIG_fail;
24458 swig_obj[0] = args;
24459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24460 if (!SWIG_IsOK(res1)) {
24461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24462 }
24463 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24464 {
24465 PyThreadState* __tstate = wxPyBeginAllowThreads();
24466 result = (arg1)->GetPosition();
24467 wxPyEndAllowThreads(__tstate);
24468 if (PyErr_Occurred()) SWIG_fail;
24469 }
24470 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24471 return resultobj;
24472 fail:
24473 return NULL;
24474 }
24475
24476
24477 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24478 PyObject *resultobj = 0;
24479 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24480 int 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_wxDropFilesEvent, 0 | 0 );
24488 if (!SWIG_IsOK(res1)) {
24489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24490 }
24491 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24492 {
24493 PyThreadState* __tstate = wxPyBeginAllowThreads();
24494 result = (int)(arg1)->GetNumberOfFiles();
24495 wxPyEndAllowThreads(__tstate);
24496 if (PyErr_Occurred()) SWIG_fail;
24497 }
24498 resultobj = SWIG_From_int(static_cast< int >(result));
24499 return resultobj;
24500 fail:
24501 return NULL;
24502 }
24503
24504
24505 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24506 PyObject *resultobj = 0;
24507 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24508 PyObject *result = 0 ;
24509 void *argp1 = 0 ;
24510 int res1 = 0 ;
24511 PyObject *swig_obj[1] ;
24512
24513 if (!args) SWIG_fail;
24514 swig_obj[0] = args;
24515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24516 if (!SWIG_IsOK(res1)) {
24517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24518 }
24519 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24520 {
24521 PyThreadState* __tstate = wxPyBeginAllowThreads();
24522 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24523 wxPyEndAllowThreads(__tstate);
24524 if (PyErr_Occurred()) SWIG_fail;
24525 }
24526 resultobj = result;
24527 return resultobj;
24528 fail:
24529 return NULL;
24530 }
24531
24532
24533 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24534 PyObject *obj;
24535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24536 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24537 return SWIG_Py_Void();
24538 }
24539
24540 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24541 PyObject *resultobj = 0;
24542 int arg1 = (int) 0 ;
24543 wxUpdateUIEvent *result = 0 ;
24544 int val1 ;
24545 int ecode1 = 0 ;
24546 PyObject * obj0 = 0 ;
24547 char * kwnames[] = {
24548 (char *) "commandId", NULL
24549 };
24550
24551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24552 if (obj0) {
24553 ecode1 = SWIG_AsVal_int(obj0, &val1);
24554 if (!SWIG_IsOK(ecode1)) {
24555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24556 }
24557 arg1 = static_cast< int >(val1);
24558 }
24559 {
24560 PyThreadState* __tstate = wxPyBeginAllowThreads();
24561 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24562 wxPyEndAllowThreads(__tstate);
24563 if (PyErr_Occurred()) SWIG_fail;
24564 }
24565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24566 return resultobj;
24567 fail:
24568 return NULL;
24569 }
24570
24571
24572 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24573 PyObject *resultobj = 0;
24574 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24575 bool result;
24576 void *argp1 = 0 ;
24577 int res1 = 0 ;
24578 PyObject *swig_obj[1] ;
24579
24580 if (!args) SWIG_fail;
24581 swig_obj[0] = args;
24582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24583 if (!SWIG_IsOK(res1)) {
24584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24585 }
24586 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24587 {
24588 PyThreadState* __tstate = wxPyBeginAllowThreads();
24589 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24590 wxPyEndAllowThreads(__tstate);
24591 if (PyErr_Occurred()) SWIG_fail;
24592 }
24593 {
24594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24595 }
24596 return resultobj;
24597 fail:
24598 return NULL;
24599 }
24600
24601
24602 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24603 PyObject *resultobj = 0;
24604 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24605 bool result;
24606 void *argp1 = 0 ;
24607 int res1 = 0 ;
24608 PyObject *swig_obj[1] ;
24609
24610 if (!args) SWIG_fail;
24611 swig_obj[0] = args;
24612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24613 if (!SWIG_IsOK(res1)) {
24614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24615 }
24616 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24617 {
24618 PyThreadState* __tstate = wxPyBeginAllowThreads();
24619 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24620 wxPyEndAllowThreads(__tstate);
24621 if (PyErr_Occurred()) SWIG_fail;
24622 }
24623 {
24624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24625 }
24626 return resultobj;
24627 fail:
24628 return NULL;
24629 }
24630
24631
24632 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24633 PyObject *resultobj = 0;
24634 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24635 bool result;
24636 void *argp1 = 0 ;
24637 int res1 = 0 ;
24638 PyObject *swig_obj[1] ;
24639
24640 if (!args) SWIG_fail;
24641 swig_obj[0] = args;
24642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24643 if (!SWIG_IsOK(res1)) {
24644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24645 }
24646 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24647 {
24648 PyThreadState* __tstate = wxPyBeginAllowThreads();
24649 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24650 wxPyEndAllowThreads(__tstate);
24651 if (PyErr_Occurred()) SWIG_fail;
24652 }
24653 {
24654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24655 }
24656 return resultobj;
24657 fail:
24658 return NULL;
24659 }
24660
24661
24662 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24663 PyObject *resultobj = 0;
24664 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24665 wxString result;
24666 void *argp1 = 0 ;
24667 int res1 = 0 ;
24668 PyObject *swig_obj[1] ;
24669
24670 if (!args) SWIG_fail;
24671 swig_obj[0] = args;
24672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24673 if (!SWIG_IsOK(res1)) {
24674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24675 }
24676 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24677 {
24678 PyThreadState* __tstate = wxPyBeginAllowThreads();
24679 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24680 wxPyEndAllowThreads(__tstate);
24681 if (PyErr_Occurred()) SWIG_fail;
24682 }
24683 {
24684 #if wxUSE_UNICODE
24685 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24686 #else
24687 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24688 #endif
24689 }
24690 return resultobj;
24691 fail:
24692 return NULL;
24693 }
24694
24695
24696 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24697 PyObject *resultobj = 0;
24698 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24699 bool result;
24700 void *argp1 = 0 ;
24701 int res1 = 0 ;
24702 PyObject *swig_obj[1] ;
24703
24704 if (!args) SWIG_fail;
24705 swig_obj[0] = args;
24706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24707 if (!SWIG_IsOK(res1)) {
24708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24709 }
24710 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24711 {
24712 PyThreadState* __tstate = wxPyBeginAllowThreads();
24713 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24714 wxPyEndAllowThreads(__tstate);
24715 if (PyErr_Occurred()) SWIG_fail;
24716 }
24717 {
24718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24719 }
24720 return resultobj;
24721 fail:
24722 return NULL;
24723 }
24724
24725
24726 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24727 PyObject *resultobj = 0;
24728 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24729 bool result;
24730 void *argp1 = 0 ;
24731 int res1 = 0 ;
24732 PyObject *swig_obj[1] ;
24733
24734 if (!args) SWIG_fail;
24735 swig_obj[0] = args;
24736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24737 if (!SWIG_IsOK(res1)) {
24738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24739 }
24740 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24741 {
24742 PyThreadState* __tstate = wxPyBeginAllowThreads();
24743 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24744 wxPyEndAllowThreads(__tstate);
24745 if (PyErr_Occurred()) SWIG_fail;
24746 }
24747 {
24748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24749 }
24750 return resultobj;
24751 fail:
24752 return NULL;
24753 }
24754
24755
24756 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24757 PyObject *resultobj = 0;
24758 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24759 bool result;
24760 void *argp1 = 0 ;
24761 int res1 = 0 ;
24762 PyObject *swig_obj[1] ;
24763
24764 if (!args) SWIG_fail;
24765 swig_obj[0] = args;
24766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24767 if (!SWIG_IsOK(res1)) {
24768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24769 }
24770 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24771 {
24772 PyThreadState* __tstate = wxPyBeginAllowThreads();
24773 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24774 wxPyEndAllowThreads(__tstate);
24775 if (PyErr_Occurred()) SWIG_fail;
24776 }
24777 {
24778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24779 }
24780 return resultobj;
24781 fail:
24782 return NULL;
24783 }
24784
24785
24786 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24787 PyObject *resultobj = 0;
24788 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24789 bool result;
24790 void *argp1 = 0 ;
24791 int res1 = 0 ;
24792 PyObject *swig_obj[1] ;
24793
24794 if (!args) SWIG_fail;
24795 swig_obj[0] = args;
24796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24797 if (!SWIG_IsOK(res1)) {
24798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24799 }
24800 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24801 {
24802 PyThreadState* __tstate = wxPyBeginAllowThreads();
24803 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24804 wxPyEndAllowThreads(__tstate);
24805 if (PyErr_Occurred()) SWIG_fail;
24806 }
24807 {
24808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24809 }
24810 return resultobj;
24811 fail:
24812 return NULL;
24813 }
24814
24815
24816 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24817 PyObject *resultobj = 0;
24818 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24819 bool arg2 ;
24820 void *argp1 = 0 ;
24821 int res1 = 0 ;
24822 bool val2 ;
24823 int ecode2 = 0 ;
24824 PyObject * obj0 = 0 ;
24825 PyObject * obj1 = 0 ;
24826 char * kwnames[] = {
24827 (char *) "self",(char *) "check", NULL
24828 };
24829
24830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24832 if (!SWIG_IsOK(res1)) {
24833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24834 }
24835 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24836 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24837 if (!SWIG_IsOK(ecode2)) {
24838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24839 }
24840 arg2 = static_cast< bool >(val2);
24841 {
24842 PyThreadState* __tstate = wxPyBeginAllowThreads();
24843 (arg1)->Check(arg2);
24844 wxPyEndAllowThreads(__tstate);
24845 if (PyErr_Occurred()) SWIG_fail;
24846 }
24847 resultobj = SWIG_Py_Void();
24848 return resultobj;
24849 fail:
24850 return NULL;
24851 }
24852
24853
24854 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24855 PyObject *resultobj = 0;
24856 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24857 bool arg2 ;
24858 void *argp1 = 0 ;
24859 int res1 = 0 ;
24860 bool val2 ;
24861 int ecode2 = 0 ;
24862 PyObject * obj0 = 0 ;
24863 PyObject * obj1 = 0 ;
24864 char * kwnames[] = {
24865 (char *) "self",(char *) "enable", NULL
24866 };
24867
24868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24870 if (!SWIG_IsOK(res1)) {
24871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24872 }
24873 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24874 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24875 if (!SWIG_IsOK(ecode2)) {
24876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24877 }
24878 arg2 = static_cast< bool >(val2);
24879 {
24880 PyThreadState* __tstate = wxPyBeginAllowThreads();
24881 (arg1)->Enable(arg2);
24882 wxPyEndAllowThreads(__tstate);
24883 if (PyErr_Occurred()) SWIG_fail;
24884 }
24885 resultobj = SWIG_Py_Void();
24886 return resultobj;
24887 fail:
24888 return NULL;
24889 }
24890
24891
24892 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24893 PyObject *resultobj = 0;
24894 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24895 bool arg2 ;
24896 void *argp1 = 0 ;
24897 int res1 = 0 ;
24898 bool val2 ;
24899 int ecode2 = 0 ;
24900 PyObject * obj0 = 0 ;
24901 PyObject * obj1 = 0 ;
24902 char * kwnames[] = {
24903 (char *) "self",(char *) "show", NULL
24904 };
24905
24906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24908 if (!SWIG_IsOK(res1)) {
24909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24910 }
24911 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24912 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24913 if (!SWIG_IsOK(ecode2)) {
24914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
24915 }
24916 arg2 = static_cast< bool >(val2);
24917 {
24918 PyThreadState* __tstate = wxPyBeginAllowThreads();
24919 (arg1)->Show(arg2);
24920 wxPyEndAllowThreads(__tstate);
24921 if (PyErr_Occurred()) SWIG_fail;
24922 }
24923 resultobj = SWIG_Py_Void();
24924 return resultobj;
24925 fail:
24926 return NULL;
24927 }
24928
24929
24930 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24931 PyObject *resultobj = 0;
24932 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24933 wxString *arg2 = 0 ;
24934 void *argp1 = 0 ;
24935 int res1 = 0 ;
24936 bool temp2 = false ;
24937 PyObject * obj0 = 0 ;
24938 PyObject * obj1 = 0 ;
24939 char * kwnames[] = {
24940 (char *) "self",(char *) "text", NULL
24941 };
24942
24943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
24944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24945 if (!SWIG_IsOK(res1)) {
24946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24947 }
24948 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24949 {
24950 arg2 = wxString_in_helper(obj1);
24951 if (arg2 == NULL) SWIG_fail;
24952 temp2 = true;
24953 }
24954 {
24955 PyThreadState* __tstate = wxPyBeginAllowThreads();
24956 (arg1)->SetText((wxString const &)*arg2);
24957 wxPyEndAllowThreads(__tstate);
24958 if (PyErr_Occurred()) SWIG_fail;
24959 }
24960 resultobj = SWIG_Py_Void();
24961 {
24962 if (temp2)
24963 delete arg2;
24964 }
24965 return resultobj;
24966 fail:
24967 {
24968 if (temp2)
24969 delete arg2;
24970 }
24971 return NULL;
24972 }
24973
24974
24975 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24976 PyObject *resultobj = 0;
24977 long arg1 ;
24978 long val1 ;
24979 int ecode1 = 0 ;
24980 PyObject * obj0 = 0 ;
24981 char * kwnames[] = {
24982 (char *) "updateInterval", NULL
24983 };
24984
24985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
24986 ecode1 = SWIG_AsVal_long(obj0, &val1);
24987 if (!SWIG_IsOK(ecode1)) {
24988 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
24989 }
24990 arg1 = static_cast< long >(val1);
24991 {
24992 PyThreadState* __tstate = wxPyBeginAllowThreads();
24993 wxUpdateUIEvent::SetUpdateInterval(arg1);
24994 wxPyEndAllowThreads(__tstate);
24995 if (PyErr_Occurred()) SWIG_fail;
24996 }
24997 resultobj = SWIG_Py_Void();
24998 return resultobj;
24999 fail:
25000 return NULL;
25001 }
25002
25003
25004 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25005 PyObject *resultobj = 0;
25006 long result;
25007
25008 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25009 {
25010 PyThreadState* __tstate = wxPyBeginAllowThreads();
25011 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25012 wxPyEndAllowThreads(__tstate);
25013 if (PyErr_Occurred()) SWIG_fail;
25014 }
25015 resultobj = SWIG_From_long(static_cast< long >(result));
25016 return resultobj;
25017 fail:
25018 return NULL;
25019 }
25020
25021
25022 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25023 PyObject *resultobj = 0;
25024 wxWindow *arg1 = (wxWindow *) 0 ;
25025 bool result;
25026 void *argp1 = 0 ;
25027 int res1 = 0 ;
25028 PyObject * obj0 = 0 ;
25029 char * kwnames[] = {
25030 (char *) "win", NULL
25031 };
25032
25033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25035 if (!SWIG_IsOK(res1)) {
25036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25037 }
25038 arg1 = reinterpret_cast< wxWindow * >(argp1);
25039 {
25040 PyThreadState* __tstate = wxPyBeginAllowThreads();
25041 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25042 wxPyEndAllowThreads(__tstate);
25043 if (PyErr_Occurred()) SWIG_fail;
25044 }
25045 {
25046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25047 }
25048 return resultobj;
25049 fail:
25050 return NULL;
25051 }
25052
25053
25054 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25055 PyObject *resultobj = 0;
25056
25057 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25058 {
25059 PyThreadState* __tstate = wxPyBeginAllowThreads();
25060 wxUpdateUIEvent::ResetUpdateTime();
25061 wxPyEndAllowThreads(__tstate);
25062 if (PyErr_Occurred()) SWIG_fail;
25063 }
25064 resultobj = SWIG_Py_Void();
25065 return resultobj;
25066 fail:
25067 return NULL;
25068 }
25069
25070
25071 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25072 PyObject *resultobj = 0;
25073 wxUpdateUIMode arg1 ;
25074 int val1 ;
25075 int ecode1 = 0 ;
25076 PyObject * obj0 = 0 ;
25077 char * kwnames[] = {
25078 (char *) "mode", NULL
25079 };
25080
25081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25082 ecode1 = SWIG_AsVal_int(obj0, &val1);
25083 if (!SWIG_IsOK(ecode1)) {
25084 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25085 }
25086 arg1 = static_cast< wxUpdateUIMode >(val1);
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 wxUpdateUIEvent::SetMode(arg1);
25090 wxPyEndAllowThreads(__tstate);
25091 if (PyErr_Occurred()) SWIG_fail;
25092 }
25093 resultobj = SWIG_Py_Void();
25094 return resultobj;
25095 fail:
25096 return NULL;
25097 }
25098
25099
25100 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25101 PyObject *resultobj = 0;
25102 wxUpdateUIMode result;
25103
25104 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25105 {
25106 PyThreadState* __tstate = wxPyBeginAllowThreads();
25107 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25108 wxPyEndAllowThreads(__tstate);
25109 if (PyErr_Occurred()) SWIG_fail;
25110 }
25111 resultobj = SWIG_From_int(static_cast< int >(result));
25112 return resultobj;
25113 fail:
25114 return NULL;
25115 }
25116
25117
25118 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25119 PyObject *obj;
25120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25121 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25122 return SWIG_Py_Void();
25123 }
25124
25125 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25126 return SWIG_Python_InitShadowInstance(args);
25127 }
25128
25129 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25130 PyObject *resultobj = 0;
25131 wxSysColourChangedEvent *result = 0 ;
25132
25133 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25134 {
25135 PyThreadState* __tstate = wxPyBeginAllowThreads();
25136 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25137 wxPyEndAllowThreads(__tstate);
25138 if (PyErr_Occurred()) SWIG_fail;
25139 }
25140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25141 return resultobj;
25142 fail:
25143 return NULL;
25144 }
25145
25146
25147 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25148 PyObject *obj;
25149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25150 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25151 return SWIG_Py_Void();
25152 }
25153
25154 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25155 return SWIG_Python_InitShadowInstance(args);
25156 }
25157
25158 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25159 PyObject *resultobj = 0;
25160 int arg1 = (int) 0 ;
25161 wxWindow *arg2 = (wxWindow *) NULL ;
25162 wxMouseCaptureChangedEvent *result = 0 ;
25163 int val1 ;
25164 int ecode1 = 0 ;
25165 void *argp2 = 0 ;
25166 int res2 = 0 ;
25167 PyObject * obj0 = 0 ;
25168 PyObject * obj1 = 0 ;
25169 char * kwnames[] = {
25170 (char *) "winid",(char *) "gainedCapture", NULL
25171 };
25172
25173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25174 if (obj0) {
25175 ecode1 = SWIG_AsVal_int(obj0, &val1);
25176 if (!SWIG_IsOK(ecode1)) {
25177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25178 }
25179 arg1 = static_cast< int >(val1);
25180 }
25181 if (obj1) {
25182 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25183 if (!SWIG_IsOK(res2)) {
25184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25185 }
25186 arg2 = reinterpret_cast< wxWindow * >(argp2);
25187 }
25188 {
25189 PyThreadState* __tstate = wxPyBeginAllowThreads();
25190 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25191 wxPyEndAllowThreads(__tstate);
25192 if (PyErr_Occurred()) SWIG_fail;
25193 }
25194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25195 return resultobj;
25196 fail:
25197 return NULL;
25198 }
25199
25200
25201 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25202 PyObject *resultobj = 0;
25203 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25204 wxWindow *result = 0 ;
25205 void *argp1 = 0 ;
25206 int res1 = 0 ;
25207 PyObject *swig_obj[1] ;
25208
25209 if (!args) SWIG_fail;
25210 swig_obj[0] = args;
25211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25212 if (!SWIG_IsOK(res1)) {
25213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25214 }
25215 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25216 {
25217 PyThreadState* __tstate = wxPyBeginAllowThreads();
25218 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25219 wxPyEndAllowThreads(__tstate);
25220 if (PyErr_Occurred()) SWIG_fail;
25221 }
25222 {
25223 resultobj = wxPyMake_wxObject(result, (bool)0);
25224 }
25225 return resultobj;
25226 fail:
25227 return NULL;
25228 }
25229
25230
25231 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25232 PyObject *obj;
25233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25234 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25235 return SWIG_Py_Void();
25236 }
25237
25238 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25239 return SWIG_Python_InitShadowInstance(args);
25240 }
25241
25242 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25243 PyObject *resultobj = 0;
25244 wxDisplayChangedEvent *result = 0 ;
25245
25246 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25247 {
25248 PyThreadState* __tstate = wxPyBeginAllowThreads();
25249 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25250 wxPyEndAllowThreads(__tstate);
25251 if (PyErr_Occurred()) SWIG_fail;
25252 }
25253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25254 return resultobj;
25255 fail:
25256 return NULL;
25257 }
25258
25259
25260 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25261 PyObject *obj;
25262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25263 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25264 return SWIG_Py_Void();
25265 }
25266
25267 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25268 return SWIG_Python_InitShadowInstance(args);
25269 }
25270
25271 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25272 PyObject *resultobj = 0;
25273 int arg1 = (int) 0 ;
25274 wxPaletteChangedEvent *result = 0 ;
25275 int val1 ;
25276 int ecode1 = 0 ;
25277 PyObject * obj0 = 0 ;
25278 char * kwnames[] = {
25279 (char *) "id", NULL
25280 };
25281
25282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25283 if (obj0) {
25284 ecode1 = SWIG_AsVal_int(obj0, &val1);
25285 if (!SWIG_IsOK(ecode1)) {
25286 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25287 }
25288 arg1 = static_cast< int >(val1);
25289 }
25290 {
25291 PyThreadState* __tstate = wxPyBeginAllowThreads();
25292 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25293 wxPyEndAllowThreads(__tstate);
25294 if (PyErr_Occurred()) SWIG_fail;
25295 }
25296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25297 return resultobj;
25298 fail:
25299 return NULL;
25300 }
25301
25302
25303 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25304 PyObject *resultobj = 0;
25305 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25306 wxWindow *arg2 = (wxWindow *) 0 ;
25307 void *argp1 = 0 ;
25308 int res1 = 0 ;
25309 void *argp2 = 0 ;
25310 int res2 = 0 ;
25311 PyObject * obj0 = 0 ;
25312 PyObject * obj1 = 0 ;
25313 char * kwnames[] = {
25314 (char *) "self",(char *) "win", NULL
25315 };
25316
25317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25319 if (!SWIG_IsOK(res1)) {
25320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25321 }
25322 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25323 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25324 if (!SWIG_IsOK(res2)) {
25325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25326 }
25327 arg2 = reinterpret_cast< wxWindow * >(argp2);
25328 {
25329 PyThreadState* __tstate = wxPyBeginAllowThreads();
25330 (arg1)->SetChangedWindow(arg2);
25331 wxPyEndAllowThreads(__tstate);
25332 if (PyErr_Occurred()) SWIG_fail;
25333 }
25334 resultobj = SWIG_Py_Void();
25335 return resultobj;
25336 fail:
25337 return NULL;
25338 }
25339
25340
25341 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25342 PyObject *resultobj = 0;
25343 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25344 wxWindow *result = 0 ;
25345 void *argp1 = 0 ;
25346 int res1 = 0 ;
25347 PyObject *swig_obj[1] ;
25348
25349 if (!args) SWIG_fail;
25350 swig_obj[0] = args;
25351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25352 if (!SWIG_IsOK(res1)) {
25353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25354 }
25355 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25356 {
25357 PyThreadState* __tstate = wxPyBeginAllowThreads();
25358 result = (wxWindow *)(arg1)->GetChangedWindow();
25359 wxPyEndAllowThreads(__tstate);
25360 if (PyErr_Occurred()) SWIG_fail;
25361 }
25362 {
25363 resultobj = wxPyMake_wxObject(result, (bool)0);
25364 }
25365 return resultobj;
25366 fail:
25367 return NULL;
25368 }
25369
25370
25371 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25372 PyObject *obj;
25373 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25374 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25375 return SWIG_Py_Void();
25376 }
25377
25378 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25379 return SWIG_Python_InitShadowInstance(args);
25380 }
25381
25382 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25383 PyObject *resultobj = 0;
25384 int arg1 = (int) 0 ;
25385 wxQueryNewPaletteEvent *result = 0 ;
25386 int val1 ;
25387 int ecode1 = 0 ;
25388 PyObject * obj0 = 0 ;
25389 char * kwnames[] = {
25390 (char *) "winid", NULL
25391 };
25392
25393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25394 if (obj0) {
25395 ecode1 = SWIG_AsVal_int(obj0, &val1);
25396 if (!SWIG_IsOK(ecode1)) {
25397 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25398 }
25399 arg1 = static_cast< int >(val1);
25400 }
25401 {
25402 PyThreadState* __tstate = wxPyBeginAllowThreads();
25403 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25404 wxPyEndAllowThreads(__tstate);
25405 if (PyErr_Occurred()) SWIG_fail;
25406 }
25407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25408 return resultobj;
25409 fail:
25410 return NULL;
25411 }
25412
25413
25414 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25415 PyObject *resultobj = 0;
25416 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25417 bool arg2 ;
25418 void *argp1 = 0 ;
25419 int res1 = 0 ;
25420 bool val2 ;
25421 int ecode2 = 0 ;
25422 PyObject * obj0 = 0 ;
25423 PyObject * obj1 = 0 ;
25424 char * kwnames[] = {
25425 (char *) "self",(char *) "realized", NULL
25426 };
25427
25428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25430 if (!SWIG_IsOK(res1)) {
25431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25432 }
25433 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25434 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25435 if (!SWIG_IsOK(ecode2)) {
25436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25437 }
25438 arg2 = static_cast< bool >(val2);
25439 {
25440 PyThreadState* __tstate = wxPyBeginAllowThreads();
25441 (arg1)->SetPaletteRealized(arg2);
25442 wxPyEndAllowThreads(__tstate);
25443 if (PyErr_Occurred()) SWIG_fail;
25444 }
25445 resultobj = SWIG_Py_Void();
25446 return resultobj;
25447 fail:
25448 return NULL;
25449 }
25450
25451
25452 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25453 PyObject *resultobj = 0;
25454 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25455 bool result;
25456 void *argp1 = 0 ;
25457 int res1 = 0 ;
25458 PyObject *swig_obj[1] ;
25459
25460 if (!args) SWIG_fail;
25461 swig_obj[0] = args;
25462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25463 if (!SWIG_IsOK(res1)) {
25464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25465 }
25466 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25467 {
25468 PyThreadState* __tstate = wxPyBeginAllowThreads();
25469 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25470 wxPyEndAllowThreads(__tstate);
25471 if (PyErr_Occurred()) SWIG_fail;
25472 }
25473 {
25474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25475 }
25476 return resultobj;
25477 fail:
25478 return NULL;
25479 }
25480
25481
25482 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25483 PyObject *obj;
25484 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25485 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25486 return SWIG_Py_Void();
25487 }
25488
25489 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25490 return SWIG_Python_InitShadowInstance(args);
25491 }
25492
25493 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25494 PyObject *resultobj = 0;
25495 wxNavigationKeyEvent *result = 0 ;
25496
25497 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25498 {
25499 PyThreadState* __tstate = wxPyBeginAllowThreads();
25500 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25501 wxPyEndAllowThreads(__tstate);
25502 if (PyErr_Occurred()) SWIG_fail;
25503 }
25504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25505 return resultobj;
25506 fail:
25507 return NULL;
25508 }
25509
25510
25511 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25512 PyObject *resultobj = 0;
25513 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25514 bool result;
25515 void *argp1 = 0 ;
25516 int res1 = 0 ;
25517 PyObject *swig_obj[1] ;
25518
25519 if (!args) SWIG_fail;
25520 swig_obj[0] = args;
25521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25522 if (!SWIG_IsOK(res1)) {
25523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25524 }
25525 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25526 {
25527 PyThreadState* __tstate = wxPyBeginAllowThreads();
25528 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25529 wxPyEndAllowThreads(__tstate);
25530 if (PyErr_Occurred()) SWIG_fail;
25531 }
25532 {
25533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25534 }
25535 return resultobj;
25536 fail:
25537 return NULL;
25538 }
25539
25540
25541 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25542 PyObject *resultobj = 0;
25543 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25544 bool arg2 ;
25545 void *argp1 = 0 ;
25546 int res1 = 0 ;
25547 bool val2 ;
25548 int ecode2 = 0 ;
25549 PyObject * obj0 = 0 ;
25550 PyObject * obj1 = 0 ;
25551 char * kwnames[] = {
25552 (char *) "self",(char *) "forward", NULL
25553 };
25554
25555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25557 if (!SWIG_IsOK(res1)) {
25558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25559 }
25560 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25561 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25562 if (!SWIG_IsOK(ecode2)) {
25563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25564 }
25565 arg2 = static_cast< bool >(val2);
25566 {
25567 PyThreadState* __tstate = wxPyBeginAllowThreads();
25568 (arg1)->SetDirection(arg2);
25569 wxPyEndAllowThreads(__tstate);
25570 if (PyErr_Occurred()) SWIG_fail;
25571 }
25572 resultobj = SWIG_Py_Void();
25573 return resultobj;
25574 fail:
25575 return NULL;
25576 }
25577
25578
25579 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25580 PyObject *resultobj = 0;
25581 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25582 bool result;
25583 void *argp1 = 0 ;
25584 int res1 = 0 ;
25585 PyObject *swig_obj[1] ;
25586
25587 if (!args) SWIG_fail;
25588 swig_obj[0] = args;
25589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25590 if (!SWIG_IsOK(res1)) {
25591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25592 }
25593 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25594 {
25595 PyThreadState* __tstate = wxPyBeginAllowThreads();
25596 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25597 wxPyEndAllowThreads(__tstate);
25598 if (PyErr_Occurred()) SWIG_fail;
25599 }
25600 {
25601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25602 }
25603 return resultobj;
25604 fail:
25605 return NULL;
25606 }
25607
25608
25609 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25610 PyObject *resultobj = 0;
25611 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25612 bool arg2 ;
25613 void *argp1 = 0 ;
25614 int res1 = 0 ;
25615 bool val2 ;
25616 int ecode2 = 0 ;
25617 PyObject * obj0 = 0 ;
25618 PyObject * obj1 = 0 ;
25619 char * kwnames[] = {
25620 (char *) "self",(char *) "ischange", NULL
25621 };
25622
25623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25625 if (!SWIG_IsOK(res1)) {
25626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25627 }
25628 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25629 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25630 if (!SWIG_IsOK(ecode2)) {
25631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25632 }
25633 arg2 = static_cast< bool >(val2);
25634 {
25635 PyThreadState* __tstate = wxPyBeginAllowThreads();
25636 (arg1)->SetWindowChange(arg2);
25637 wxPyEndAllowThreads(__tstate);
25638 if (PyErr_Occurred()) SWIG_fail;
25639 }
25640 resultobj = SWIG_Py_Void();
25641 return resultobj;
25642 fail:
25643 return NULL;
25644 }
25645
25646
25647 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25648 PyObject *resultobj = 0;
25649 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25650 bool result;
25651 void *argp1 = 0 ;
25652 int res1 = 0 ;
25653 PyObject *swig_obj[1] ;
25654
25655 if (!args) SWIG_fail;
25656 swig_obj[0] = args;
25657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25658 if (!SWIG_IsOK(res1)) {
25659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25660 }
25661 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25662 {
25663 PyThreadState* __tstate = wxPyBeginAllowThreads();
25664 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25665 wxPyEndAllowThreads(__tstate);
25666 if (PyErr_Occurred()) SWIG_fail;
25667 }
25668 {
25669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25670 }
25671 return resultobj;
25672 fail:
25673 return NULL;
25674 }
25675
25676
25677 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25678 PyObject *resultobj = 0;
25679 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25680 bool arg2 ;
25681 void *argp1 = 0 ;
25682 int res1 = 0 ;
25683 bool val2 ;
25684 int ecode2 = 0 ;
25685 PyObject * obj0 = 0 ;
25686 PyObject * obj1 = 0 ;
25687 char * kwnames[] = {
25688 (char *) "self",(char *) "bIs", NULL
25689 };
25690
25691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25693 if (!SWIG_IsOK(res1)) {
25694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25695 }
25696 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25697 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25698 if (!SWIG_IsOK(ecode2)) {
25699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25700 }
25701 arg2 = static_cast< bool >(val2);
25702 {
25703 PyThreadState* __tstate = wxPyBeginAllowThreads();
25704 (arg1)->SetFromTab(arg2);
25705 wxPyEndAllowThreads(__tstate);
25706 if (PyErr_Occurred()) SWIG_fail;
25707 }
25708 resultobj = SWIG_Py_Void();
25709 return resultobj;
25710 fail:
25711 return NULL;
25712 }
25713
25714
25715 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25716 PyObject *resultobj = 0;
25717 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25718 long arg2 ;
25719 void *argp1 = 0 ;
25720 int res1 = 0 ;
25721 long val2 ;
25722 int ecode2 = 0 ;
25723 PyObject * obj0 = 0 ;
25724 PyObject * obj1 = 0 ;
25725 char * kwnames[] = {
25726 (char *) "self",(char *) "flags", NULL
25727 };
25728
25729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25731 if (!SWIG_IsOK(res1)) {
25732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25733 }
25734 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25735 ecode2 = SWIG_AsVal_long(obj1, &val2);
25736 if (!SWIG_IsOK(ecode2)) {
25737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25738 }
25739 arg2 = static_cast< long >(val2);
25740 {
25741 PyThreadState* __tstate = wxPyBeginAllowThreads();
25742 (arg1)->SetFlags(arg2);
25743 wxPyEndAllowThreads(__tstate);
25744 if (PyErr_Occurred()) SWIG_fail;
25745 }
25746 resultobj = SWIG_Py_Void();
25747 return resultobj;
25748 fail:
25749 return NULL;
25750 }
25751
25752
25753 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25754 PyObject *resultobj = 0;
25755 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25756 wxWindow *result = 0 ;
25757 void *argp1 = 0 ;
25758 int res1 = 0 ;
25759 PyObject *swig_obj[1] ;
25760
25761 if (!args) SWIG_fail;
25762 swig_obj[0] = args;
25763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25764 if (!SWIG_IsOK(res1)) {
25765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25766 }
25767 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25768 {
25769 PyThreadState* __tstate = wxPyBeginAllowThreads();
25770 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25771 wxPyEndAllowThreads(__tstate);
25772 if (PyErr_Occurred()) SWIG_fail;
25773 }
25774 {
25775 resultobj = wxPyMake_wxObject(result, (bool)0);
25776 }
25777 return resultobj;
25778 fail:
25779 return NULL;
25780 }
25781
25782
25783 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25784 PyObject *resultobj = 0;
25785 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25786 wxWindow *arg2 = (wxWindow *) 0 ;
25787 void *argp1 = 0 ;
25788 int res1 = 0 ;
25789 void *argp2 = 0 ;
25790 int res2 = 0 ;
25791 PyObject * obj0 = 0 ;
25792 PyObject * obj1 = 0 ;
25793 char * kwnames[] = {
25794 (char *) "self",(char *) "win", NULL
25795 };
25796
25797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25799 if (!SWIG_IsOK(res1)) {
25800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25801 }
25802 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25803 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25804 if (!SWIG_IsOK(res2)) {
25805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25806 }
25807 arg2 = reinterpret_cast< wxWindow * >(argp2);
25808 {
25809 PyThreadState* __tstate = wxPyBeginAllowThreads();
25810 (arg1)->SetCurrentFocus(arg2);
25811 wxPyEndAllowThreads(__tstate);
25812 if (PyErr_Occurred()) SWIG_fail;
25813 }
25814 resultobj = SWIG_Py_Void();
25815 return resultobj;
25816 fail:
25817 return NULL;
25818 }
25819
25820
25821 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25822 PyObject *obj;
25823 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25824 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25825 return SWIG_Py_Void();
25826 }
25827
25828 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25829 return SWIG_Python_InitShadowInstance(args);
25830 }
25831
25832 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25833 PyObject *resultobj = 0;
25834 wxWindow *arg1 = (wxWindow *) NULL ;
25835 wxWindowCreateEvent *result = 0 ;
25836 void *argp1 = 0 ;
25837 int res1 = 0 ;
25838 PyObject * obj0 = 0 ;
25839 char * kwnames[] = {
25840 (char *) "win", NULL
25841 };
25842
25843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25844 if (obj0) {
25845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25846 if (!SWIG_IsOK(res1)) {
25847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25848 }
25849 arg1 = reinterpret_cast< wxWindow * >(argp1);
25850 }
25851 {
25852 PyThreadState* __tstate = wxPyBeginAllowThreads();
25853 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25854 wxPyEndAllowThreads(__tstate);
25855 if (PyErr_Occurred()) SWIG_fail;
25856 }
25857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25858 return resultobj;
25859 fail:
25860 return NULL;
25861 }
25862
25863
25864 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25865 PyObject *resultobj = 0;
25866 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25867 wxWindow *result = 0 ;
25868 void *argp1 = 0 ;
25869 int res1 = 0 ;
25870 PyObject *swig_obj[1] ;
25871
25872 if (!args) SWIG_fail;
25873 swig_obj[0] = args;
25874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25875 if (!SWIG_IsOK(res1)) {
25876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25877 }
25878 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25879 {
25880 PyThreadState* __tstate = wxPyBeginAllowThreads();
25881 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25882 wxPyEndAllowThreads(__tstate);
25883 if (PyErr_Occurred()) SWIG_fail;
25884 }
25885 {
25886 resultobj = wxPyMake_wxObject(result, (bool)0);
25887 }
25888 return resultobj;
25889 fail:
25890 return NULL;
25891 }
25892
25893
25894 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25895 PyObject *obj;
25896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25897 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25898 return SWIG_Py_Void();
25899 }
25900
25901 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25902 return SWIG_Python_InitShadowInstance(args);
25903 }
25904
25905 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25906 PyObject *resultobj = 0;
25907 wxWindow *arg1 = (wxWindow *) NULL ;
25908 wxWindowDestroyEvent *result = 0 ;
25909 void *argp1 = 0 ;
25910 int res1 = 0 ;
25911 PyObject * obj0 = 0 ;
25912 char * kwnames[] = {
25913 (char *) "win", NULL
25914 };
25915
25916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
25917 if (obj0) {
25918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25919 if (!SWIG_IsOK(res1)) {
25920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25921 }
25922 arg1 = reinterpret_cast< wxWindow * >(argp1);
25923 }
25924 {
25925 PyThreadState* __tstate = wxPyBeginAllowThreads();
25926 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
25927 wxPyEndAllowThreads(__tstate);
25928 if (PyErr_Occurred()) SWIG_fail;
25929 }
25930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
25931 return resultobj;
25932 fail:
25933 return NULL;
25934 }
25935
25936
25937 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25938 PyObject *resultobj = 0;
25939 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
25940 wxWindow *result = 0 ;
25941 void *argp1 = 0 ;
25942 int res1 = 0 ;
25943 PyObject *swig_obj[1] ;
25944
25945 if (!args) SWIG_fail;
25946 swig_obj[0] = args;
25947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
25948 if (!SWIG_IsOK(res1)) {
25949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
25950 }
25951 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
25952 {
25953 PyThreadState* __tstate = wxPyBeginAllowThreads();
25954 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
25955 wxPyEndAllowThreads(__tstate);
25956 if (PyErr_Occurred()) SWIG_fail;
25957 }
25958 {
25959 resultobj = wxPyMake_wxObject(result, (bool)0);
25960 }
25961 return resultobj;
25962 fail:
25963 return NULL;
25964 }
25965
25966
25967 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25968 PyObject *obj;
25969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25970 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
25971 return SWIG_Py_Void();
25972 }
25973
25974 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25975 return SWIG_Python_InitShadowInstance(args);
25976 }
25977
25978 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25979 PyObject *resultobj = 0;
25980 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
25981 int arg2 = (int) 0 ;
25982 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25983 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25984 wxContextMenuEvent *result = 0 ;
25985 int val1 ;
25986 int ecode1 = 0 ;
25987 int val2 ;
25988 int ecode2 = 0 ;
25989 wxPoint temp3 ;
25990 PyObject * obj0 = 0 ;
25991 PyObject * obj1 = 0 ;
25992 PyObject * obj2 = 0 ;
25993 char * kwnames[] = {
25994 (char *) "type",(char *) "winid",(char *) "pt", NULL
25995 };
25996
25997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25998 if (obj0) {
25999 ecode1 = SWIG_AsVal_int(obj0, &val1);
26000 if (!SWIG_IsOK(ecode1)) {
26001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26002 }
26003 arg1 = static_cast< wxEventType >(val1);
26004 }
26005 if (obj1) {
26006 ecode2 = SWIG_AsVal_int(obj1, &val2);
26007 if (!SWIG_IsOK(ecode2)) {
26008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26009 }
26010 arg2 = static_cast< int >(val2);
26011 }
26012 if (obj2) {
26013 {
26014 arg3 = &temp3;
26015 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26016 }
26017 }
26018 {
26019 PyThreadState* __tstate = wxPyBeginAllowThreads();
26020 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26021 wxPyEndAllowThreads(__tstate);
26022 if (PyErr_Occurred()) SWIG_fail;
26023 }
26024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26025 return resultobj;
26026 fail:
26027 return NULL;
26028 }
26029
26030
26031 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26032 PyObject *resultobj = 0;
26033 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26034 wxPoint *result = 0 ;
26035 void *argp1 = 0 ;
26036 int res1 = 0 ;
26037 PyObject *swig_obj[1] ;
26038
26039 if (!args) SWIG_fail;
26040 swig_obj[0] = args;
26041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26042 if (!SWIG_IsOK(res1)) {
26043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26044 }
26045 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 {
26049 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26050 result = (wxPoint *) &_result_ref;
26051 }
26052 wxPyEndAllowThreads(__tstate);
26053 if (PyErr_Occurred()) SWIG_fail;
26054 }
26055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26056 return resultobj;
26057 fail:
26058 return NULL;
26059 }
26060
26061
26062 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26063 PyObject *resultobj = 0;
26064 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26065 wxPoint *arg2 = 0 ;
26066 void *argp1 = 0 ;
26067 int res1 = 0 ;
26068 wxPoint temp2 ;
26069 PyObject * obj0 = 0 ;
26070 PyObject * obj1 = 0 ;
26071 char * kwnames[] = {
26072 (char *) "self",(char *) "pos", NULL
26073 };
26074
26075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26077 if (!SWIG_IsOK(res1)) {
26078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26079 }
26080 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26081 {
26082 arg2 = &temp2;
26083 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26084 }
26085 {
26086 PyThreadState* __tstate = wxPyBeginAllowThreads();
26087 (arg1)->SetPosition((wxPoint const &)*arg2);
26088 wxPyEndAllowThreads(__tstate);
26089 if (PyErr_Occurred()) SWIG_fail;
26090 }
26091 resultobj = SWIG_Py_Void();
26092 return resultobj;
26093 fail:
26094 return NULL;
26095 }
26096
26097
26098 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26099 PyObject *obj;
26100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26101 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26102 return SWIG_Py_Void();
26103 }
26104
26105 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26106 return SWIG_Python_InitShadowInstance(args);
26107 }
26108
26109 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26110 PyObject *resultobj = 0;
26111 wxIdleEvent *result = 0 ;
26112
26113 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26114 {
26115 PyThreadState* __tstate = wxPyBeginAllowThreads();
26116 result = (wxIdleEvent *)new wxIdleEvent();
26117 wxPyEndAllowThreads(__tstate);
26118 if (PyErr_Occurred()) SWIG_fail;
26119 }
26120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26121 return resultobj;
26122 fail:
26123 return NULL;
26124 }
26125
26126
26127 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26128 PyObject *resultobj = 0;
26129 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26130 bool arg2 = (bool) true ;
26131 void *argp1 = 0 ;
26132 int res1 = 0 ;
26133 bool val2 ;
26134 int ecode2 = 0 ;
26135 PyObject * obj0 = 0 ;
26136 PyObject * obj1 = 0 ;
26137 char * kwnames[] = {
26138 (char *) "self",(char *) "needMore", NULL
26139 };
26140
26141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26143 if (!SWIG_IsOK(res1)) {
26144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26145 }
26146 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26147 if (obj1) {
26148 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26149 if (!SWIG_IsOK(ecode2)) {
26150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26151 }
26152 arg2 = static_cast< bool >(val2);
26153 }
26154 {
26155 PyThreadState* __tstate = wxPyBeginAllowThreads();
26156 (arg1)->RequestMore(arg2);
26157 wxPyEndAllowThreads(__tstate);
26158 if (PyErr_Occurred()) SWIG_fail;
26159 }
26160 resultobj = SWIG_Py_Void();
26161 return resultobj;
26162 fail:
26163 return NULL;
26164 }
26165
26166
26167 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26168 PyObject *resultobj = 0;
26169 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26170 bool result;
26171 void *argp1 = 0 ;
26172 int res1 = 0 ;
26173 PyObject *swig_obj[1] ;
26174
26175 if (!args) SWIG_fail;
26176 swig_obj[0] = args;
26177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26178 if (!SWIG_IsOK(res1)) {
26179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26180 }
26181 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26182 {
26183 PyThreadState* __tstate = wxPyBeginAllowThreads();
26184 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26185 wxPyEndAllowThreads(__tstate);
26186 if (PyErr_Occurred()) SWIG_fail;
26187 }
26188 {
26189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26190 }
26191 return resultobj;
26192 fail:
26193 return NULL;
26194 }
26195
26196
26197 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26198 PyObject *resultobj = 0;
26199 wxIdleMode arg1 ;
26200 int val1 ;
26201 int ecode1 = 0 ;
26202 PyObject * obj0 = 0 ;
26203 char * kwnames[] = {
26204 (char *) "mode", NULL
26205 };
26206
26207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26208 ecode1 = SWIG_AsVal_int(obj0, &val1);
26209 if (!SWIG_IsOK(ecode1)) {
26210 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26211 }
26212 arg1 = static_cast< wxIdleMode >(val1);
26213 {
26214 PyThreadState* __tstate = wxPyBeginAllowThreads();
26215 wxIdleEvent::SetMode(arg1);
26216 wxPyEndAllowThreads(__tstate);
26217 if (PyErr_Occurred()) SWIG_fail;
26218 }
26219 resultobj = SWIG_Py_Void();
26220 return resultobj;
26221 fail:
26222 return NULL;
26223 }
26224
26225
26226 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26227 PyObject *resultobj = 0;
26228 wxIdleMode result;
26229
26230 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26231 {
26232 PyThreadState* __tstate = wxPyBeginAllowThreads();
26233 result = (wxIdleMode)wxIdleEvent::GetMode();
26234 wxPyEndAllowThreads(__tstate);
26235 if (PyErr_Occurred()) SWIG_fail;
26236 }
26237 resultobj = SWIG_From_int(static_cast< int >(result));
26238 return resultobj;
26239 fail:
26240 return NULL;
26241 }
26242
26243
26244 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26245 PyObject *resultobj = 0;
26246 wxWindow *arg1 = (wxWindow *) 0 ;
26247 bool result;
26248 void *argp1 = 0 ;
26249 int res1 = 0 ;
26250 PyObject * obj0 = 0 ;
26251 char * kwnames[] = {
26252 (char *) "win", NULL
26253 };
26254
26255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26257 if (!SWIG_IsOK(res1)) {
26258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26259 }
26260 arg1 = reinterpret_cast< wxWindow * >(argp1);
26261 {
26262 PyThreadState* __tstate = wxPyBeginAllowThreads();
26263 result = (bool)wxIdleEvent::CanSend(arg1);
26264 wxPyEndAllowThreads(__tstate);
26265 if (PyErr_Occurred()) SWIG_fail;
26266 }
26267 {
26268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26269 }
26270 return resultobj;
26271 fail:
26272 return NULL;
26273 }
26274
26275
26276 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26277 PyObject *obj;
26278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26279 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26280 return SWIG_Py_Void();
26281 }
26282
26283 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26284 return SWIG_Python_InitShadowInstance(args);
26285 }
26286
26287 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26288 PyObject *resultobj = 0;
26289 int arg1 = (int) 0 ;
26290 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26291 wxPyEvent *result = 0 ;
26292 int val1 ;
26293 int ecode1 = 0 ;
26294 int val2 ;
26295 int ecode2 = 0 ;
26296 PyObject * obj0 = 0 ;
26297 PyObject * obj1 = 0 ;
26298 char * kwnames[] = {
26299 (char *) "winid",(char *) "eventType", NULL
26300 };
26301
26302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26303 if (obj0) {
26304 ecode1 = SWIG_AsVal_int(obj0, &val1);
26305 if (!SWIG_IsOK(ecode1)) {
26306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26307 }
26308 arg1 = static_cast< int >(val1);
26309 }
26310 if (obj1) {
26311 ecode2 = SWIG_AsVal_int(obj1, &val2);
26312 if (!SWIG_IsOK(ecode2)) {
26313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26314 }
26315 arg2 = static_cast< wxEventType >(val2);
26316 }
26317 {
26318 PyThreadState* __tstate = wxPyBeginAllowThreads();
26319 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26320 wxPyEndAllowThreads(__tstate);
26321 if (PyErr_Occurred()) SWIG_fail;
26322 }
26323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26324 return resultobj;
26325 fail:
26326 return NULL;
26327 }
26328
26329
26330 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26331 PyObject *resultobj = 0;
26332 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26333 void *argp1 = 0 ;
26334 int res1 = 0 ;
26335 PyObject *swig_obj[1] ;
26336
26337 if (!args) SWIG_fail;
26338 swig_obj[0] = args;
26339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26340 if (!SWIG_IsOK(res1)) {
26341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26342 }
26343 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26344 {
26345 PyThreadState* __tstate = wxPyBeginAllowThreads();
26346 delete arg1;
26347
26348 wxPyEndAllowThreads(__tstate);
26349 if (PyErr_Occurred()) SWIG_fail;
26350 }
26351 resultobj = SWIG_Py_Void();
26352 return resultobj;
26353 fail:
26354 return NULL;
26355 }
26356
26357
26358 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26359 PyObject *resultobj = 0;
26360 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26361 PyObject *arg2 = (PyObject *) 0 ;
26362 void *argp1 = 0 ;
26363 int res1 = 0 ;
26364 PyObject * obj0 = 0 ;
26365 PyObject * obj1 = 0 ;
26366 char * kwnames[] = {
26367 (char *) "self",(char *) "self", NULL
26368 };
26369
26370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26372 if (!SWIG_IsOK(res1)) {
26373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26374 }
26375 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26376 arg2 = obj1;
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 (arg1)->SetSelf(arg2);
26380 wxPyEndAllowThreads(__tstate);
26381 if (PyErr_Occurred()) SWIG_fail;
26382 }
26383 resultobj = SWIG_Py_Void();
26384 return resultobj;
26385 fail:
26386 return NULL;
26387 }
26388
26389
26390 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26391 PyObject *resultobj = 0;
26392 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26393 PyObject *result = 0 ;
26394 void *argp1 = 0 ;
26395 int res1 = 0 ;
26396 PyObject *swig_obj[1] ;
26397
26398 if (!args) SWIG_fail;
26399 swig_obj[0] = args;
26400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26401 if (!SWIG_IsOK(res1)) {
26402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26403 }
26404 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26405 {
26406 PyThreadState* __tstate = wxPyBeginAllowThreads();
26407 result = (PyObject *)(arg1)->GetSelf();
26408 wxPyEndAllowThreads(__tstate);
26409 if (PyErr_Occurred()) SWIG_fail;
26410 }
26411 resultobj = result;
26412 return resultobj;
26413 fail:
26414 return NULL;
26415 }
26416
26417
26418 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26419 PyObject *obj;
26420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26421 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26422 return SWIG_Py_Void();
26423 }
26424
26425 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26426 return SWIG_Python_InitShadowInstance(args);
26427 }
26428
26429 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26430 PyObject *resultobj = 0;
26431 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26432 int arg2 = (int) 0 ;
26433 wxPyCommandEvent *result = 0 ;
26434 int val1 ;
26435 int ecode1 = 0 ;
26436 int val2 ;
26437 int ecode2 = 0 ;
26438 PyObject * obj0 = 0 ;
26439 PyObject * obj1 = 0 ;
26440 char * kwnames[] = {
26441 (char *) "eventType",(char *) "id", NULL
26442 };
26443
26444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26445 if (obj0) {
26446 ecode1 = SWIG_AsVal_int(obj0, &val1);
26447 if (!SWIG_IsOK(ecode1)) {
26448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26449 }
26450 arg1 = static_cast< wxEventType >(val1);
26451 }
26452 if (obj1) {
26453 ecode2 = SWIG_AsVal_int(obj1, &val2);
26454 if (!SWIG_IsOK(ecode2)) {
26455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26456 }
26457 arg2 = static_cast< int >(val2);
26458 }
26459 {
26460 PyThreadState* __tstate = wxPyBeginAllowThreads();
26461 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26462 wxPyEndAllowThreads(__tstate);
26463 if (PyErr_Occurred()) SWIG_fail;
26464 }
26465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26466 return resultobj;
26467 fail:
26468 return NULL;
26469 }
26470
26471
26472 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26473 PyObject *resultobj = 0;
26474 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26475 void *argp1 = 0 ;
26476 int res1 = 0 ;
26477 PyObject *swig_obj[1] ;
26478
26479 if (!args) SWIG_fail;
26480 swig_obj[0] = args;
26481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26482 if (!SWIG_IsOK(res1)) {
26483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26484 }
26485 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26486 {
26487 PyThreadState* __tstate = wxPyBeginAllowThreads();
26488 delete arg1;
26489
26490 wxPyEndAllowThreads(__tstate);
26491 if (PyErr_Occurred()) SWIG_fail;
26492 }
26493 resultobj = SWIG_Py_Void();
26494 return resultobj;
26495 fail:
26496 return NULL;
26497 }
26498
26499
26500 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26501 PyObject *resultobj = 0;
26502 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26503 PyObject *arg2 = (PyObject *) 0 ;
26504 void *argp1 = 0 ;
26505 int res1 = 0 ;
26506 PyObject * obj0 = 0 ;
26507 PyObject * obj1 = 0 ;
26508 char * kwnames[] = {
26509 (char *) "self",(char *) "self", NULL
26510 };
26511
26512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26514 if (!SWIG_IsOK(res1)) {
26515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26516 }
26517 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26518 arg2 = obj1;
26519 {
26520 PyThreadState* __tstate = wxPyBeginAllowThreads();
26521 (arg1)->SetSelf(arg2);
26522 wxPyEndAllowThreads(__tstate);
26523 if (PyErr_Occurred()) SWIG_fail;
26524 }
26525 resultobj = SWIG_Py_Void();
26526 return resultobj;
26527 fail:
26528 return NULL;
26529 }
26530
26531
26532 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26533 PyObject *resultobj = 0;
26534 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26535 PyObject *result = 0 ;
26536 void *argp1 = 0 ;
26537 int res1 = 0 ;
26538 PyObject *swig_obj[1] ;
26539
26540 if (!args) SWIG_fail;
26541 swig_obj[0] = args;
26542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26543 if (!SWIG_IsOK(res1)) {
26544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26545 }
26546 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26547 {
26548 PyThreadState* __tstate = wxPyBeginAllowThreads();
26549 result = (PyObject *)(arg1)->GetSelf();
26550 wxPyEndAllowThreads(__tstate);
26551 if (PyErr_Occurred()) SWIG_fail;
26552 }
26553 resultobj = result;
26554 return resultobj;
26555 fail:
26556 return NULL;
26557 }
26558
26559
26560 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26561 PyObject *obj;
26562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26563 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26564 return SWIG_Py_Void();
26565 }
26566
26567 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26568 return SWIG_Python_InitShadowInstance(args);
26569 }
26570
26571 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26572 PyObject *resultobj = 0;
26573 wxWindow *arg1 = (wxWindow *) 0 ;
26574 wxDateTime *arg2 = 0 ;
26575 wxEventType arg3 ;
26576 wxDateEvent *result = 0 ;
26577 void *argp1 = 0 ;
26578 int res1 = 0 ;
26579 void *argp2 = 0 ;
26580 int res2 = 0 ;
26581 int val3 ;
26582 int ecode3 = 0 ;
26583 PyObject * obj0 = 0 ;
26584 PyObject * obj1 = 0 ;
26585 PyObject * obj2 = 0 ;
26586 char * kwnames[] = {
26587 (char *) "win",(char *) "dt",(char *) "type", NULL
26588 };
26589
26590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26592 if (!SWIG_IsOK(res1)) {
26593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26594 }
26595 arg1 = reinterpret_cast< wxWindow * >(argp1);
26596 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26597 if (!SWIG_IsOK(res2)) {
26598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26599 }
26600 if (!argp2) {
26601 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26602 }
26603 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26604 ecode3 = SWIG_AsVal_int(obj2, &val3);
26605 if (!SWIG_IsOK(ecode3)) {
26606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26607 }
26608 arg3 = static_cast< wxEventType >(val3);
26609 {
26610 PyThreadState* __tstate = wxPyBeginAllowThreads();
26611 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26612 wxPyEndAllowThreads(__tstate);
26613 if (PyErr_Occurred()) SWIG_fail;
26614 }
26615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26616 return resultobj;
26617 fail:
26618 return NULL;
26619 }
26620
26621
26622 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26623 PyObject *resultobj = 0;
26624 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26625 wxDateTime *result = 0 ;
26626 void *argp1 = 0 ;
26627 int res1 = 0 ;
26628 PyObject *swig_obj[1] ;
26629
26630 if (!args) SWIG_fail;
26631 swig_obj[0] = args;
26632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26633 if (!SWIG_IsOK(res1)) {
26634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26635 }
26636 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26637 {
26638 PyThreadState* __tstate = wxPyBeginAllowThreads();
26639 {
26640 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26641 result = (wxDateTime *) &_result_ref;
26642 }
26643 wxPyEndAllowThreads(__tstate);
26644 if (PyErr_Occurred()) SWIG_fail;
26645 }
26646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26647 return resultobj;
26648 fail:
26649 return NULL;
26650 }
26651
26652
26653 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26654 PyObject *resultobj = 0;
26655 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26656 wxDateTime *arg2 = 0 ;
26657 void *argp1 = 0 ;
26658 int res1 = 0 ;
26659 void *argp2 = 0 ;
26660 int res2 = 0 ;
26661 PyObject * obj0 = 0 ;
26662 PyObject * obj1 = 0 ;
26663 char * kwnames[] = {
26664 (char *) "self",(char *) "date", NULL
26665 };
26666
26667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26669 if (!SWIG_IsOK(res1)) {
26670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26671 }
26672 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26673 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26674 if (!SWIG_IsOK(res2)) {
26675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26676 }
26677 if (!argp2) {
26678 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26679 }
26680 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26681 {
26682 PyThreadState* __tstate = wxPyBeginAllowThreads();
26683 (arg1)->SetDate((wxDateTime const &)*arg2);
26684 wxPyEndAllowThreads(__tstate);
26685 if (PyErr_Occurred()) SWIG_fail;
26686 }
26687 resultobj = SWIG_Py_Void();
26688 return resultobj;
26689 fail:
26690 return NULL;
26691 }
26692
26693
26694 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26695 PyObject *obj;
26696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26697 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26698 return SWIG_Py_Void();
26699 }
26700
26701 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26702 return SWIG_Python_InitShadowInstance(args);
26703 }
26704
26705 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26706 PyObject *resultobj = 0;
26707 wxPyApp *result = 0 ;
26708
26709 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26710 {
26711 PyThreadState* __tstate = wxPyBeginAllowThreads();
26712 result = (wxPyApp *)new_wxPyApp();
26713 wxPyEndAllowThreads(__tstate);
26714 if (PyErr_Occurred()) SWIG_fail;
26715 }
26716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26717 return resultobj;
26718 fail:
26719 return NULL;
26720 }
26721
26722
26723 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26724 PyObject *resultobj = 0;
26725 wxPyApp *arg1 = (wxPyApp *) 0 ;
26726 void *argp1 = 0 ;
26727 int res1 = 0 ;
26728 PyObject *swig_obj[1] ;
26729
26730 if (!args) SWIG_fail;
26731 swig_obj[0] = args;
26732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26733 if (!SWIG_IsOK(res1)) {
26734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26735 }
26736 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26737 {
26738 PyThreadState* __tstate = wxPyBeginAllowThreads();
26739 delete arg1;
26740
26741 wxPyEndAllowThreads(__tstate);
26742 if (PyErr_Occurred()) SWIG_fail;
26743 }
26744 resultobj = SWIG_Py_Void();
26745 return resultobj;
26746 fail:
26747 return NULL;
26748 }
26749
26750
26751 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26752 PyObject *resultobj = 0;
26753 wxPyApp *arg1 = (wxPyApp *) 0 ;
26754 PyObject *arg2 = (PyObject *) 0 ;
26755 PyObject *arg3 = (PyObject *) 0 ;
26756 bool arg4 ;
26757 void *argp1 = 0 ;
26758 int res1 = 0 ;
26759 bool val4 ;
26760 int ecode4 = 0 ;
26761 PyObject * obj0 = 0 ;
26762 PyObject * obj1 = 0 ;
26763 PyObject * obj2 = 0 ;
26764 PyObject * obj3 = 0 ;
26765 char * kwnames[] = {
26766 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26767 };
26768
26769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26771 if (!SWIG_IsOK(res1)) {
26772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26773 }
26774 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26775 arg2 = obj1;
26776 arg3 = obj2;
26777 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26778 if (!SWIG_IsOK(ecode4)) {
26779 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26780 }
26781 arg4 = static_cast< bool >(val4);
26782 {
26783 PyThreadState* __tstate = wxPyBeginAllowThreads();
26784 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26785 wxPyEndAllowThreads(__tstate);
26786 if (PyErr_Occurred()) SWIG_fail;
26787 }
26788 resultobj = SWIG_Py_Void();
26789 return resultobj;
26790 fail:
26791 return NULL;
26792 }
26793
26794
26795 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26796 PyObject *resultobj = 0;
26797 wxPyApp *arg1 = (wxPyApp *) 0 ;
26798 wxString result;
26799 void *argp1 = 0 ;
26800 int res1 = 0 ;
26801 PyObject *swig_obj[1] ;
26802
26803 if (!args) SWIG_fail;
26804 swig_obj[0] = args;
26805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26806 if (!SWIG_IsOK(res1)) {
26807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26808 }
26809 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26810 {
26811 PyThreadState* __tstate = wxPyBeginAllowThreads();
26812 result = ((wxPyApp const *)arg1)->GetAppName();
26813 wxPyEndAllowThreads(__tstate);
26814 if (PyErr_Occurred()) SWIG_fail;
26815 }
26816 {
26817 #if wxUSE_UNICODE
26818 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26819 #else
26820 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26821 #endif
26822 }
26823 return resultobj;
26824 fail:
26825 return NULL;
26826 }
26827
26828
26829 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26830 PyObject *resultobj = 0;
26831 wxPyApp *arg1 = (wxPyApp *) 0 ;
26832 wxString *arg2 = 0 ;
26833 void *argp1 = 0 ;
26834 int res1 = 0 ;
26835 bool temp2 = false ;
26836 PyObject * obj0 = 0 ;
26837 PyObject * obj1 = 0 ;
26838 char * kwnames[] = {
26839 (char *) "self",(char *) "name", NULL
26840 };
26841
26842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26844 if (!SWIG_IsOK(res1)) {
26845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26846 }
26847 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26848 {
26849 arg2 = wxString_in_helper(obj1);
26850 if (arg2 == NULL) SWIG_fail;
26851 temp2 = true;
26852 }
26853 {
26854 PyThreadState* __tstate = wxPyBeginAllowThreads();
26855 (arg1)->SetAppName((wxString const &)*arg2);
26856 wxPyEndAllowThreads(__tstate);
26857 if (PyErr_Occurred()) SWIG_fail;
26858 }
26859 resultobj = SWIG_Py_Void();
26860 {
26861 if (temp2)
26862 delete arg2;
26863 }
26864 return resultobj;
26865 fail:
26866 {
26867 if (temp2)
26868 delete arg2;
26869 }
26870 return NULL;
26871 }
26872
26873
26874 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26875 PyObject *resultobj = 0;
26876 wxPyApp *arg1 = (wxPyApp *) 0 ;
26877 wxString result;
26878 void *argp1 = 0 ;
26879 int res1 = 0 ;
26880 PyObject *swig_obj[1] ;
26881
26882 if (!args) SWIG_fail;
26883 swig_obj[0] = args;
26884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26885 if (!SWIG_IsOK(res1)) {
26886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26887 }
26888 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26889 {
26890 PyThreadState* __tstate = wxPyBeginAllowThreads();
26891 result = ((wxPyApp const *)arg1)->GetClassName();
26892 wxPyEndAllowThreads(__tstate);
26893 if (PyErr_Occurred()) SWIG_fail;
26894 }
26895 {
26896 #if wxUSE_UNICODE
26897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26898 #else
26899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26900 #endif
26901 }
26902 return resultobj;
26903 fail:
26904 return NULL;
26905 }
26906
26907
26908 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26909 PyObject *resultobj = 0;
26910 wxPyApp *arg1 = (wxPyApp *) 0 ;
26911 wxString *arg2 = 0 ;
26912 void *argp1 = 0 ;
26913 int res1 = 0 ;
26914 bool temp2 = false ;
26915 PyObject * obj0 = 0 ;
26916 PyObject * obj1 = 0 ;
26917 char * kwnames[] = {
26918 (char *) "self",(char *) "name", NULL
26919 };
26920
26921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
26922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26923 if (!SWIG_IsOK(res1)) {
26924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26925 }
26926 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26927 {
26928 arg2 = wxString_in_helper(obj1);
26929 if (arg2 == NULL) SWIG_fail;
26930 temp2 = true;
26931 }
26932 {
26933 PyThreadState* __tstate = wxPyBeginAllowThreads();
26934 (arg1)->SetClassName((wxString const &)*arg2);
26935 wxPyEndAllowThreads(__tstate);
26936 if (PyErr_Occurred()) SWIG_fail;
26937 }
26938 resultobj = SWIG_Py_Void();
26939 {
26940 if (temp2)
26941 delete arg2;
26942 }
26943 return resultobj;
26944 fail:
26945 {
26946 if (temp2)
26947 delete arg2;
26948 }
26949 return NULL;
26950 }
26951
26952
26953 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26954 PyObject *resultobj = 0;
26955 wxPyApp *arg1 = (wxPyApp *) 0 ;
26956 wxString *result = 0 ;
26957 void *argp1 = 0 ;
26958 int res1 = 0 ;
26959 PyObject *swig_obj[1] ;
26960
26961 if (!args) SWIG_fail;
26962 swig_obj[0] = args;
26963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26964 if (!SWIG_IsOK(res1)) {
26965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26966 }
26967 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26968 {
26969 PyThreadState* __tstate = wxPyBeginAllowThreads();
26970 {
26971 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
26972 result = (wxString *) &_result_ref;
26973 }
26974 wxPyEndAllowThreads(__tstate);
26975 if (PyErr_Occurred()) SWIG_fail;
26976 }
26977 {
26978 #if wxUSE_UNICODE
26979 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
26980 #else
26981 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
26982 #endif
26983 }
26984 return resultobj;
26985 fail:
26986 return NULL;
26987 }
26988
26989
26990 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26991 PyObject *resultobj = 0;
26992 wxPyApp *arg1 = (wxPyApp *) 0 ;
26993 wxString *arg2 = 0 ;
26994 void *argp1 = 0 ;
26995 int res1 = 0 ;
26996 bool temp2 = false ;
26997 PyObject * obj0 = 0 ;
26998 PyObject * obj1 = 0 ;
26999 char * kwnames[] = {
27000 (char *) "self",(char *) "name", NULL
27001 };
27002
27003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27005 if (!SWIG_IsOK(res1)) {
27006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27007 }
27008 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27009 {
27010 arg2 = wxString_in_helper(obj1);
27011 if (arg2 == NULL) SWIG_fail;
27012 temp2 = true;
27013 }
27014 {
27015 PyThreadState* __tstate = wxPyBeginAllowThreads();
27016 (arg1)->SetVendorName((wxString const &)*arg2);
27017 wxPyEndAllowThreads(__tstate);
27018 if (PyErr_Occurred()) SWIG_fail;
27019 }
27020 resultobj = SWIG_Py_Void();
27021 {
27022 if (temp2)
27023 delete arg2;
27024 }
27025 return resultobj;
27026 fail:
27027 {
27028 if (temp2)
27029 delete arg2;
27030 }
27031 return NULL;
27032 }
27033
27034
27035 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27036 PyObject *resultobj = 0;
27037 wxPyApp *arg1 = (wxPyApp *) 0 ;
27038 wxAppTraits *result = 0 ;
27039 void *argp1 = 0 ;
27040 int res1 = 0 ;
27041 PyObject *swig_obj[1] ;
27042
27043 if (!args) SWIG_fail;
27044 swig_obj[0] = args;
27045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27046 if (!SWIG_IsOK(res1)) {
27047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27048 }
27049 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27050 {
27051 PyThreadState* __tstate = wxPyBeginAllowThreads();
27052 result = (wxAppTraits *)(arg1)->GetTraits();
27053 wxPyEndAllowThreads(__tstate);
27054 if (PyErr_Occurred()) SWIG_fail;
27055 }
27056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27057 return resultobj;
27058 fail:
27059 return NULL;
27060 }
27061
27062
27063 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27064 PyObject *resultobj = 0;
27065 wxPyApp *arg1 = (wxPyApp *) 0 ;
27066 void *argp1 = 0 ;
27067 int res1 = 0 ;
27068 PyObject *swig_obj[1] ;
27069
27070 if (!args) SWIG_fail;
27071 swig_obj[0] = args;
27072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27073 if (!SWIG_IsOK(res1)) {
27074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27075 }
27076 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27077 {
27078 PyThreadState* __tstate = wxPyBeginAllowThreads();
27079 (arg1)->ProcessPendingEvents();
27080 wxPyEndAllowThreads(__tstate);
27081 if (PyErr_Occurred()) SWIG_fail;
27082 }
27083 resultobj = SWIG_Py_Void();
27084 return resultobj;
27085 fail:
27086 return NULL;
27087 }
27088
27089
27090 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27091 PyObject *resultobj = 0;
27092 wxPyApp *arg1 = (wxPyApp *) 0 ;
27093 bool arg2 = (bool) false ;
27094 bool result;
27095 void *argp1 = 0 ;
27096 int res1 = 0 ;
27097 bool val2 ;
27098 int ecode2 = 0 ;
27099 PyObject * obj0 = 0 ;
27100 PyObject * obj1 = 0 ;
27101 char * kwnames[] = {
27102 (char *) "self",(char *) "onlyIfNeeded", NULL
27103 };
27104
27105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27107 if (!SWIG_IsOK(res1)) {
27108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27109 }
27110 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27111 if (obj1) {
27112 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27113 if (!SWIG_IsOK(ecode2)) {
27114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27115 }
27116 arg2 = static_cast< bool >(val2);
27117 }
27118 {
27119 PyThreadState* __tstate = wxPyBeginAllowThreads();
27120 result = (bool)(arg1)->Yield(arg2);
27121 wxPyEndAllowThreads(__tstate);
27122 if (PyErr_Occurred()) SWIG_fail;
27123 }
27124 {
27125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27126 }
27127 return resultobj;
27128 fail:
27129 return NULL;
27130 }
27131
27132
27133 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27134 PyObject *resultobj = 0;
27135 wxPyApp *arg1 = (wxPyApp *) 0 ;
27136 void *argp1 = 0 ;
27137 int res1 = 0 ;
27138 PyObject *swig_obj[1] ;
27139
27140 if (!args) SWIG_fail;
27141 swig_obj[0] = args;
27142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27143 if (!SWIG_IsOK(res1)) {
27144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27145 }
27146 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27147 {
27148 PyThreadState* __tstate = wxPyBeginAllowThreads();
27149 (arg1)->WakeUpIdle();
27150 wxPyEndAllowThreads(__tstate);
27151 if (PyErr_Occurred()) SWIG_fail;
27152 }
27153 resultobj = SWIG_Py_Void();
27154 return resultobj;
27155 fail:
27156 return NULL;
27157 }
27158
27159
27160 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27161 PyObject *resultobj = 0;
27162 bool result;
27163
27164 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27165 {
27166 PyThreadState* __tstate = wxPyBeginAllowThreads();
27167 result = (bool)wxPyApp::IsMainLoopRunning();
27168 wxPyEndAllowThreads(__tstate);
27169 if (PyErr_Occurred()) SWIG_fail;
27170 }
27171 {
27172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27173 }
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27181 PyObject *resultobj = 0;
27182 wxPyApp *arg1 = (wxPyApp *) 0 ;
27183 int result;
27184 void *argp1 = 0 ;
27185 int res1 = 0 ;
27186 PyObject *swig_obj[1] ;
27187
27188 if (!args) SWIG_fail;
27189 swig_obj[0] = args;
27190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27191 if (!SWIG_IsOK(res1)) {
27192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27193 }
27194 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27195 {
27196 PyThreadState* __tstate = wxPyBeginAllowThreads();
27197 result = (int)(arg1)->MainLoop();
27198 wxPyEndAllowThreads(__tstate);
27199 if (PyErr_Occurred()) SWIG_fail;
27200 }
27201 resultobj = SWIG_From_int(static_cast< int >(result));
27202 return resultobj;
27203 fail:
27204 return NULL;
27205 }
27206
27207
27208 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27209 PyObject *resultobj = 0;
27210 wxPyApp *arg1 = (wxPyApp *) 0 ;
27211 void *argp1 = 0 ;
27212 int res1 = 0 ;
27213 PyObject *swig_obj[1] ;
27214
27215 if (!args) SWIG_fail;
27216 swig_obj[0] = args;
27217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27218 if (!SWIG_IsOK(res1)) {
27219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27220 }
27221 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 (arg1)->Exit();
27225 wxPyEndAllowThreads(__tstate);
27226 if (PyErr_Occurred()) SWIG_fail;
27227 }
27228 resultobj = SWIG_Py_Void();
27229 return resultobj;
27230 fail:
27231 return NULL;
27232 }
27233
27234
27235 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27236 PyObject *resultobj = 0;
27237 wxPyApp *arg1 = (wxPyApp *) 0 ;
27238 void *argp1 = 0 ;
27239 int res1 = 0 ;
27240 PyObject *swig_obj[1] ;
27241
27242 if (!args) SWIG_fail;
27243 swig_obj[0] = args;
27244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27245 if (!SWIG_IsOK(res1)) {
27246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27247 }
27248 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27249 {
27250 PyThreadState* __tstate = wxPyBeginAllowThreads();
27251 (arg1)->ExitMainLoop();
27252 wxPyEndAllowThreads(__tstate);
27253 if (PyErr_Occurred()) SWIG_fail;
27254 }
27255 resultobj = SWIG_Py_Void();
27256 return resultobj;
27257 fail:
27258 return NULL;
27259 }
27260
27261
27262 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27263 PyObject *resultobj = 0;
27264 wxPyApp *arg1 = (wxPyApp *) 0 ;
27265 bool result;
27266 void *argp1 = 0 ;
27267 int res1 = 0 ;
27268 PyObject *swig_obj[1] ;
27269
27270 if (!args) SWIG_fail;
27271 swig_obj[0] = args;
27272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27273 if (!SWIG_IsOK(res1)) {
27274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27275 }
27276 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27277 {
27278 PyThreadState* __tstate = wxPyBeginAllowThreads();
27279 result = (bool)(arg1)->Pending();
27280 wxPyEndAllowThreads(__tstate);
27281 if (PyErr_Occurred()) SWIG_fail;
27282 }
27283 {
27284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27285 }
27286 return resultobj;
27287 fail:
27288 return NULL;
27289 }
27290
27291
27292 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27293 PyObject *resultobj = 0;
27294 wxPyApp *arg1 = (wxPyApp *) 0 ;
27295 bool result;
27296 void *argp1 = 0 ;
27297 int res1 = 0 ;
27298 PyObject *swig_obj[1] ;
27299
27300 if (!args) SWIG_fail;
27301 swig_obj[0] = args;
27302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27303 if (!SWIG_IsOK(res1)) {
27304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27305 }
27306 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27307 {
27308 PyThreadState* __tstate = wxPyBeginAllowThreads();
27309 result = (bool)(arg1)->Dispatch();
27310 wxPyEndAllowThreads(__tstate);
27311 if (PyErr_Occurred()) SWIG_fail;
27312 }
27313 {
27314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27315 }
27316 return resultobj;
27317 fail:
27318 return NULL;
27319 }
27320
27321
27322 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27323 PyObject *resultobj = 0;
27324 wxPyApp *arg1 = (wxPyApp *) 0 ;
27325 bool result;
27326 void *argp1 = 0 ;
27327 int res1 = 0 ;
27328 PyObject *swig_obj[1] ;
27329
27330 if (!args) SWIG_fail;
27331 swig_obj[0] = args;
27332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27333 if (!SWIG_IsOK(res1)) {
27334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27335 }
27336 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27337 {
27338 PyThreadState* __tstate = wxPyBeginAllowThreads();
27339 result = (bool)(arg1)->ProcessIdle();
27340 wxPyEndAllowThreads(__tstate);
27341 if (PyErr_Occurred()) SWIG_fail;
27342 }
27343 {
27344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27345 }
27346 return resultobj;
27347 fail:
27348 return NULL;
27349 }
27350
27351
27352 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27353 PyObject *resultobj = 0;
27354 wxPyApp *arg1 = (wxPyApp *) 0 ;
27355 wxWindow *arg2 = (wxWindow *) 0 ;
27356 wxIdleEvent *arg3 = 0 ;
27357 bool result;
27358 void *argp1 = 0 ;
27359 int res1 = 0 ;
27360 void *argp2 = 0 ;
27361 int res2 = 0 ;
27362 void *argp3 = 0 ;
27363 int res3 = 0 ;
27364 PyObject * obj0 = 0 ;
27365 PyObject * obj1 = 0 ;
27366 PyObject * obj2 = 0 ;
27367 char * kwnames[] = {
27368 (char *) "self",(char *) "win",(char *) "event", NULL
27369 };
27370
27371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27373 if (!SWIG_IsOK(res1)) {
27374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27375 }
27376 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27378 if (!SWIG_IsOK(res2)) {
27379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27380 }
27381 arg2 = reinterpret_cast< wxWindow * >(argp2);
27382 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27383 if (!SWIG_IsOK(res3)) {
27384 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27385 }
27386 if (!argp3) {
27387 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27388 }
27389 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27390 {
27391 PyThreadState* __tstate = wxPyBeginAllowThreads();
27392 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27393 wxPyEndAllowThreads(__tstate);
27394 if (PyErr_Occurred()) SWIG_fail;
27395 }
27396 {
27397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27398 }
27399 return resultobj;
27400 fail:
27401 return NULL;
27402 }
27403
27404
27405 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27406 PyObject *resultobj = 0;
27407 wxPyApp *arg1 = (wxPyApp *) 0 ;
27408 bool result;
27409 void *argp1 = 0 ;
27410 int res1 = 0 ;
27411 PyObject *swig_obj[1] ;
27412
27413 if (!args) SWIG_fail;
27414 swig_obj[0] = args;
27415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27416 if (!SWIG_IsOK(res1)) {
27417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27418 }
27419 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27420 {
27421 PyThreadState* __tstate = wxPyBeginAllowThreads();
27422 result = (bool)((wxPyApp const *)arg1)->IsActive();
27423 wxPyEndAllowThreads(__tstate);
27424 if (PyErr_Occurred()) SWIG_fail;
27425 }
27426 {
27427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27428 }
27429 return resultobj;
27430 fail:
27431 return NULL;
27432 }
27433
27434
27435 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27436 PyObject *resultobj = 0;
27437 wxPyApp *arg1 = (wxPyApp *) 0 ;
27438 wxWindow *arg2 = (wxWindow *) 0 ;
27439 void *argp1 = 0 ;
27440 int res1 = 0 ;
27441 void *argp2 = 0 ;
27442 int res2 = 0 ;
27443 PyObject * obj0 = 0 ;
27444 PyObject * obj1 = 0 ;
27445 char * kwnames[] = {
27446 (char *) "self",(char *) "win", NULL
27447 };
27448
27449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27451 if (!SWIG_IsOK(res1)) {
27452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27453 }
27454 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27455 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27456 if (!SWIG_IsOK(res2)) {
27457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27458 }
27459 arg2 = reinterpret_cast< wxWindow * >(argp2);
27460 {
27461 PyThreadState* __tstate = wxPyBeginAllowThreads();
27462 (arg1)->SetTopWindow(arg2);
27463 wxPyEndAllowThreads(__tstate);
27464 if (PyErr_Occurred()) SWIG_fail;
27465 }
27466 resultobj = SWIG_Py_Void();
27467 return resultobj;
27468 fail:
27469 return NULL;
27470 }
27471
27472
27473 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27474 PyObject *resultobj = 0;
27475 wxPyApp *arg1 = (wxPyApp *) 0 ;
27476 wxWindow *result = 0 ;
27477 void *argp1 = 0 ;
27478 int res1 = 0 ;
27479 PyObject *swig_obj[1] ;
27480
27481 if (!args) SWIG_fail;
27482 swig_obj[0] = args;
27483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27484 if (!SWIG_IsOK(res1)) {
27485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27486 }
27487 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27488 {
27489 PyThreadState* __tstate = wxPyBeginAllowThreads();
27490 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27491 wxPyEndAllowThreads(__tstate);
27492 if (PyErr_Occurred()) SWIG_fail;
27493 }
27494 {
27495 resultobj = wxPyMake_wxObject(result, (bool)0);
27496 }
27497 return resultobj;
27498 fail:
27499 return NULL;
27500 }
27501
27502
27503 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27504 PyObject *resultobj = 0;
27505 wxPyApp *arg1 = (wxPyApp *) 0 ;
27506 bool arg2 ;
27507 void *argp1 = 0 ;
27508 int res1 = 0 ;
27509 bool val2 ;
27510 int ecode2 = 0 ;
27511 PyObject * obj0 = 0 ;
27512 PyObject * obj1 = 0 ;
27513 char * kwnames[] = {
27514 (char *) "self",(char *) "flag", NULL
27515 };
27516
27517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27519 if (!SWIG_IsOK(res1)) {
27520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27521 }
27522 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27523 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27524 if (!SWIG_IsOK(ecode2)) {
27525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27526 }
27527 arg2 = static_cast< bool >(val2);
27528 {
27529 PyThreadState* __tstate = wxPyBeginAllowThreads();
27530 (arg1)->SetExitOnFrameDelete(arg2);
27531 wxPyEndAllowThreads(__tstate);
27532 if (PyErr_Occurred()) SWIG_fail;
27533 }
27534 resultobj = SWIG_Py_Void();
27535 return resultobj;
27536 fail:
27537 return NULL;
27538 }
27539
27540
27541 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27542 PyObject *resultobj = 0;
27543 wxPyApp *arg1 = (wxPyApp *) 0 ;
27544 bool result;
27545 void *argp1 = 0 ;
27546 int res1 = 0 ;
27547 PyObject *swig_obj[1] ;
27548
27549 if (!args) SWIG_fail;
27550 swig_obj[0] = args;
27551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27552 if (!SWIG_IsOK(res1)) {
27553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27554 }
27555 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27556 {
27557 PyThreadState* __tstate = wxPyBeginAllowThreads();
27558 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27559 wxPyEndAllowThreads(__tstate);
27560 if (PyErr_Occurred()) SWIG_fail;
27561 }
27562 {
27563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27564 }
27565 return resultobj;
27566 fail:
27567 return NULL;
27568 }
27569
27570
27571 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27572 PyObject *resultobj = 0;
27573 wxPyApp *arg1 = (wxPyApp *) 0 ;
27574 bool arg2 ;
27575 void *argp1 = 0 ;
27576 int res1 = 0 ;
27577 bool val2 ;
27578 int ecode2 = 0 ;
27579 PyObject * obj0 = 0 ;
27580 PyObject * obj1 = 0 ;
27581 char * kwnames[] = {
27582 (char *) "self",(char *) "flag", NULL
27583 };
27584
27585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27587 if (!SWIG_IsOK(res1)) {
27588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27589 }
27590 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27591 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27592 if (!SWIG_IsOK(ecode2)) {
27593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27594 }
27595 arg2 = static_cast< bool >(val2);
27596 {
27597 PyThreadState* __tstate = wxPyBeginAllowThreads();
27598 (arg1)->SetUseBestVisual(arg2);
27599 wxPyEndAllowThreads(__tstate);
27600 if (PyErr_Occurred()) SWIG_fail;
27601 }
27602 resultobj = SWIG_Py_Void();
27603 return resultobj;
27604 fail:
27605 return NULL;
27606 }
27607
27608
27609 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27610 PyObject *resultobj = 0;
27611 wxPyApp *arg1 = (wxPyApp *) 0 ;
27612 bool result;
27613 void *argp1 = 0 ;
27614 int res1 = 0 ;
27615 PyObject *swig_obj[1] ;
27616
27617 if (!args) SWIG_fail;
27618 swig_obj[0] = args;
27619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27620 if (!SWIG_IsOK(res1)) {
27621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27622 }
27623 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27624 {
27625 PyThreadState* __tstate = wxPyBeginAllowThreads();
27626 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27627 wxPyEndAllowThreads(__tstate);
27628 if (PyErr_Occurred()) SWIG_fail;
27629 }
27630 {
27631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27632 }
27633 return resultobj;
27634 fail:
27635 return NULL;
27636 }
27637
27638
27639 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27640 PyObject *resultobj = 0;
27641 wxPyApp *arg1 = (wxPyApp *) 0 ;
27642 int arg2 ;
27643 void *argp1 = 0 ;
27644 int res1 = 0 ;
27645 int val2 ;
27646 int ecode2 = 0 ;
27647 PyObject * obj0 = 0 ;
27648 PyObject * obj1 = 0 ;
27649 char * kwnames[] = {
27650 (char *) "self",(char *) "mode", NULL
27651 };
27652
27653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27655 if (!SWIG_IsOK(res1)) {
27656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27657 }
27658 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27659 ecode2 = SWIG_AsVal_int(obj1, &val2);
27660 if (!SWIG_IsOK(ecode2)) {
27661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27662 }
27663 arg2 = static_cast< int >(val2);
27664 {
27665 PyThreadState* __tstate = wxPyBeginAllowThreads();
27666 (arg1)->SetPrintMode(arg2);
27667 wxPyEndAllowThreads(__tstate);
27668 if (PyErr_Occurred()) SWIG_fail;
27669 }
27670 resultobj = SWIG_Py_Void();
27671 return resultobj;
27672 fail:
27673 return NULL;
27674 }
27675
27676
27677 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27678 PyObject *resultobj = 0;
27679 wxPyApp *arg1 = (wxPyApp *) 0 ;
27680 int result;
27681 void *argp1 = 0 ;
27682 int res1 = 0 ;
27683 PyObject *swig_obj[1] ;
27684
27685 if (!args) SWIG_fail;
27686 swig_obj[0] = args;
27687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27688 if (!SWIG_IsOK(res1)) {
27689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27690 }
27691 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27692 {
27693 PyThreadState* __tstate = wxPyBeginAllowThreads();
27694 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27695 wxPyEndAllowThreads(__tstate);
27696 if (PyErr_Occurred()) SWIG_fail;
27697 }
27698 resultobj = SWIG_From_int(static_cast< int >(result));
27699 return resultobj;
27700 fail:
27701 return NULL;
27702 }
27703
27704
27705 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27706 PyObject *resultobj = 0;
27707 wxPyApp *arg1 = (wxPyApp *) 0 ;
27708 int arg2 ;
27709 void *argp1 = 0 ;
27710 int res1 = 0 ;
27711 int val2 ;
27712 int ecode2 = 0 ;
27713 PyObject * obj0 = 0 ;
27714 PyObject * obj1 = 0 ;
27715 char * kwnames[] = {
27716 (char *) "self",(char *) "mode", NULL
27717 };
27718
27719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27721 if (!SWIG_IsOK(res1)) {
27722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27723 }
27724 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27725 ecode2 = SWIG_AsVal_int(obj1, &val2);
27726 if (!SWIG_IsOK(ecode2)) {
27727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27728 }
27729 arg2 = static_cast< int >(val2);
27730 {
27731 PyThreadState* __tstate = wxPyBeginAllowThreads();
27732 (arg1)->SetAssertMode(arg2);
27733 wxPyEndAllowThreads(__tstate);
27734 if (PyErr_Occurred()) SWIG_fail;
27735 }
27736 resultobj = SWIG_Py_Void();
27737 return resultobj;
27738 fail:
27739 return NULL;
27740 }
27741
27742
27743 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27744 PyObject *resultobj = 0;
27745 wxPyApp *arg1 = (wxPyApp *) 0 ;
27746 int result;
27747 void *argp1 = 0 ;
27748 int res1 = 0 ;
27749 PyObject *swig_obj[1] ;
27750
27751 if (!args) SWIG_fail;
27752 swig_obj[0] = args;
27753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27754 if (!SWIG_IsOK(res1)) {
27755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27756 }
27757 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27758 {
27759 PyThreadState* __tstate = wxPyBeginAllowThreads();
27760 result = (int)(arg1)->GetAssertMode();
27761 wxPyEndAllowThreads(__tstate);
27762 if (PyErr_Occurred()) SWIG_fail;
27763 }
27764 resultobj = SWIG_From_int(static_cast< int >(result));
27765 return resultobj;
27766 fail:
27767 return NULL;
27768 }
27769
27770
27771 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27772 PyObject *resultobj = 0;
27773 bool result;
27774
27775 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27776 {
27777 PyThreadState* __tstate = wxPyBeginAllowThreads();
27778 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27779 wxPyEndAllowThreads(__tstate);
27780 if (PyErr_Occurred()) SWIG_fail;
27781 }
27782 {
27783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27784 }
27785 return resultobj;
27786 fail:
27787 return NULL;
27788 }
27789
27790
27791 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27792 PyObject *resultobj = 0;
27793 long result;
27794
27795 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27796 {
27797 PyThreadState* __tstate = wxPyBeginAllowThreads();
27798 result = (long)wxPyApp::GetMacAboutMenuItemId();
27799 wxPyEndAllowThreads(__tstate);
27800 if (PyErr_Occurred()) SWIG_fail;
27801 }
27802 resultobj = SWIG_From_long(static_cast< long >(result));
27803 return resultobj;
27804 fail:
27805 return NULL;
27806 }
27807
27808
27809 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27810 PyObject *resultobj = 0;
27811 long result;
27812
27813 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27817 wxPyEndAllowThreads(__tstate);
27818 if (PyErr_Occurred()) SWIG_fail;
27819 }
27820 resultobj = SWIG_From_long(static_cast< long >(result));
27821 return resultobj;
27822 fail:
27823 return NULL;
27824 }
27825
27826
27827 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27828 PyObject *resultobj = 0;
27829 long result;
27830
27831 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27832 {
27833 PyThreadState* __tstate = wxPyBeginAllowThreads();
27834 result = (long)wxPyApp::GetMacExitMenuItemId();
27835 wxPyEndAllowThreads(__tstate);
27836 if (PyErr_Occurred()) SWIG_fail;
27837 }
27838 resultobj = SWIG_From_long(static_cast< long >(result));
27839 return resultobj;
27840 fail:
27841 return NULL;
27842 }
27843
27844
27845 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27846 PyObject *resultobj = 0;
27847 wxString result;
27848
27849 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27850 {
27851 PyThreadState* __tstate = wxPyBeginAllowThreads();
27852 result = wxPyApp::GetMacHelpMenuTitleName();
27853 wxPyEndAllowThreads(__tstate);
27854 if (PyErr_Occurred()) SWIG_fail;
27855 }
27856 {
27857 #if wxUSE_UNICODE
27858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27859 #else
27860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27861 #endif
27862 }
27863 return resultobj;
27864 fail:
27865 return NULL;
27866 }
27867
27868
27869 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27870 PyObject *resultobj = 0;
27871 bool arg1 ;
27872 bool val1 ;
27873 int ecode1 = 0 ;
27874 PyObject * obj0 = 0 ;
27875 char * kwnames[] = {
27876 (char *) "val", NULL
27877 };
27878
27879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27880 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27881 if (!SWIG_IsOK(ecode1)) {
27882 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27883 }
27884 arg1 = static_cast< bool >(val1);
27885 {
27886 PyThreadState* __tstate = wxPyBeginAllowThreads();
27887 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27888 wxPyEndAllowThreads(__tstate);
27889 if (PyErr_Occurred()) SWIG_fail;
27890 }
27891 resultobj = SWIG_Py_Void();
27892 return resultobj;
27893 fail:
27894 return NULL;
27895 }
27896
27897
27898 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27899 PyObject *resultobj = 0;
27900 long arg1 ;
27901 long val1 ;
27902 int ecode1 = 0 ;
27903 PyObject * obj0 = 0 ;
27904 char * kwnames[] = {
27905 (char *) "val", NULL
27906 };
27907
27908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
27909 ecode1 = SWIG_AsVal_long(obj0, &val1);
27910 if (!SWIG_IsOK(ecode1)) {
27911 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
27912 }
27913 arg1 = static_cast< long >(val1);
27914 {
27915 PyThreadState* __tstate = wxPyBeginAllowThreads();
27916 wxPyApp::SetMacAboutMenuItemId(arg1);
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_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27928 PyObject *resultobj = 0;
27929 long arg1 ;
27930 long val1 ;
27931 int ecode1 = 0 ;
27932 PyObject * obj0 = 0 ;
27933 char * kwnames[] = {
27934 (char *) "val", NULL
27935 };
27936
27937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
27938 ecode1 = SWIG_AsVal_long(obj0, &val1);
27939 if (!SWIG_IsOK(ecode1)) {
27940 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
27941 }
27942 arg1 = static_cast< long >(val1);
27943 {
27944 PyThreadState* __tstate = wxPyBeginAllowThreads();
27945 wxPyApp::SetMacPreferencesMenuItemId(arg1);
27946 wxPyEndAllowThreads(__tstate);
27947 if (PyErr_Occurred()) SWIG_fail;
27948 }
27949 resultobj = SWIG_Py_Void();
27950 return resultobj;
27951 fail:
27952 return NULL;
27953 }
27954
27955
27956 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27957 PyObject *resultobj = 0;
27958 long arg1 ;
27959 long val1 ;
27960 int ecode1 = 0 ;
27961 PyObject * obj0 = 0 ;
27962 char * kwnames[] = {
27963 (char *) "val", NULL
27964 };
27965
27966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
27967 ecode1 = SWIG_AsVal_long(obj0, &val1);
27968 if (!SWIG_IsOK(ecode1)) {
27969 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
27970 }
27971 arg1 = static_cast< long >(val1);
27972 {
27973 PyThreadState* __tstate = wxPyBeginAllowThreads();
27974 wxPyApp::SetMacExitMenuItemId(arg1);
27975 wxPyEndAllowThreads(__tstate);
27976 if (PyErr_Occurred()) SWIG_fail;
27977 }
27978 resultobj = SWIG_Py_Void();
27979 return resultobj;
27980 fail:
27981 return NULL;
27982 }
27983
27984
27985 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27986 PyObject *resultobj = 0;
27987 wxString *arg1 = 0 ;
27988 bool temp1 = false ;
27989 PyObject * obj0 = 0 ;
27990 char * kwnames[] = {
27991 (char *) "val", NULL
27992 };
27993
27994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
27995 {
27996 arg1 = wxString_in_helper(obj0);
27997 if (arg1 == NULL) SWIG_fail;
27998 temp1 = true;
27999 }
28000 {
28001 PyThreadState* __tstate = wxPyBeginAllowThreads();
28002 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28003 wxPyEndAllowThreads(__tstate);
28004 if (PyErr_Occurred()) SWIG_fail;
28005 }
28006 resultobj = SWIG_Py_Void();
28007 {
28008 if (temp1)
28009 delete arg1;
28010 }
28011 return resultobj;
28012 fail:
28013 {
28014 if (temp1)
28015 delete arg1;
28016 }
28017 return NULL;
28018 }
28019
28020
28021 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28022 PyObject *resultobj = 0;
28023 wxPyApp *arg1 = (wxPyApp *) 0 ;
28024 void *argp1 = 0 ;
28025 int res1 = 0 ;
28026 PyObject *swig_obj[1] ;
28027
28028 if (!args) SWIG_fail;
28029 swig_obj[0] = args;
28030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28031 if (!SWIG_IsOK(res1)) {
28032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28033 }
28034 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28035 {
28036 PyThreadState* __tstate = wxPyBeginAllowThreads();
28037 (arg1)->_BootstrapApp();
28038 wxPyEndAllowThreads(__tstate);
28039 if (PyErr_Occurred()) SWIG_fail;
28040 }
28041 resultobj = SWIG_Py_Void();
28042 return resultobj;
28043 fail:
28044 return NULL;
28045 }
28046
28047
28048 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28049 PyObject *resultobj = 0;
28050 int result;
28051
28052 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28053 {
28054 PyThreadState* __tstate = wxPyBeginAllowThreads();
28055 result = (int)wxPyApp_GetComCtl32Version();
28056 wxPyEndAllowThreads(__tstate);
28057 if (PyErr_Occurred()) SWIG_fail;
28058 }
28059 resultobj = SWIG_From_int(static_cast< int >(result));
28060 return resultobj;
28061 fail:
28062 return NULL;
28063 }
28064
28065
28066 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28067 PyObject *obj;
28068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28069 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28070 return SWIG_Py_Void();
28071 }
28072
28073 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28074 return SWIG_Python_InitShadowInstance(args);
28075 }
28076
28077 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28078 PyObject *resultobj = 0;
28079
28080 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28081 {
28082 PyThreadState* __tstate = wxPyBeginAllowThreads();
28083 wxExit();
28084 wxPyEndAllowThreads(__tstate);
28085 if (PyErr_Occurred()) SWIG_fail;
28086 }
28087 resultobj = SWIG_Py_Void();
28088 return resultobj;
28089 fail:
28090 return NULL;
28091 }
28092
28093
28094 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28095 PyObject *resultobj = 0;
28096 bool result;
28097
28098 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28099 {
28100 PyThreadState* __tstate = wxPyBeginAllowThreads();
28101 result = (bool)wxYield();
28102 wxPyEndAllowThreads(__tstate);
28103 if (PyErr_Occurred()) SWIG_fail;
28104 }
28105 {
28106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28107 }
28108 return resultobj;
28109 fail:
28110 return NULL;
28111 }
28112
28113
28114 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28115 PyObject *resultobj = 0;
28116 bool result;
28117
28118 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28119 {
28120 PyThreadState* __tstate = wxPyBeginAllowThreads();
28121 result = (bool)wxYieldIfNeeded();
28122 wxPyEndAllowThreads(__tstate);
28123 if (PyErr_Occurred()) SWIG_fail;
28124 }
28125 {
28126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28127 }
28128 return resultobj;
28129 fail:
28130 return NULL;
28131 }
28132
28133
28134 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28135 PyObject *resultobj = 0;
28136 wxWindow *arg1 = (wxWindow *) NULL ;
28137 bool arg2 = (bool) false ;
28138 bool result;
28139 void *argp1 = 0 ;
28140 int res1 = 0 ;
28141 bool val2 ;
28142 int ecode2 = 0 ;
28143 PyObject * obj0 = 0 ;
28144 PyObject * obj1 = 0 ;
28145 char * kwnames[] = {
28146 (char *) "win",(char *) "onlyIfNeeded", NULL
28147 };
28148
28149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28150 if (obj0) {
28151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28152 if (!SWIG_IsOK(res1)) {
28153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28154 }
28155 arg1 = reinterpret_cast< wxWindow * >(argp1);
28156 }
28157 if (obj1) {
28158 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28159 if (!SWIG_IsOK(ecode2)) {
28160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28161 }
28162 arg2 = static_cast< bool >(val2);
28163 }
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 result = (bool)wxSafeYield(arg1,arg2);
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 {
28171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28172 }
28173 return resultobj;
28174 fail:
28175 return NULL;
28176 }
28177
28178
28179 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28180 PyObject *resultobj = 0;
28181
28182 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28183 {
28184 PyThreadState* __tstate = wxPyBeginAllowThreads();
28185 wxWakeUpIdle();
28186 wxPyEndAllowThreads(__tstate);
28187 if (PyErr_Occurred()) SWIG_fail;
28188 }
28189 resultobj = SWIG_Py_Void();
28190 return resultobj;
28191 fail:
28192 return NULL;
28193 }
28194
28195
28196 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28197 PyObject *resultobj = 0;
28198 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28199 wxEvent *arg2 = 0 ;
28200 void *argp1 = 0 ;
28201 int res1 = 0 ;
28202 void *argp2 = 0 ;
28203 int res2 = 0 ;
28204 PyObject * obj0 = 0 ;
28205 PyObject * obj1 = 0 ;
28206 char * kwnames[] = {
28207 (char *) "dest",(char *) "event", NULL
28208 };
28209
28210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28212 if (!SWIG_IsOK(res1)) {
28213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28214 }
28215 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28216 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28217 if (!SWIG_IsOK(res2)) {
28218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28219 }
28220 if (!argp2) {
28221 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28222 }
28223 arg2 = reinterpret_cast< wxEvent * >(argp2);
28224 {
28225 PyThreadState* __tstate = wxPyBeginAllowThreads();
28226 wxPostEvent(arg1,*arg2);
28227 wxPyEndAllowThreads(__tstate);
28228 if (PyErr_Occurred()) SWIG_fail;
28229 }
28230 resultobj = SWIG_Py_Void();
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28238 PyObject *resultobj = 0;
28239
28240 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28241 {
28242 PyThreadState* __tstate = wxPyBeginAllowThreads();
28243 wxApp_CleanUp();
28244 wxPyEndAllowThreads(__tstate);
28245 if (PyErr_Occurred()) SWIG_fail;
28246 }
28247 resultobj = SWIG_Py_Void();
28248 return resultobj;
28249 fail:
28250 return NULL;
28251 }
28252
28253
28254 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28255 PyObject *resultobj = 0;
28256 wxPyApp *result = 0 ;
28257
28258 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28259 {
28260 PyThreadState* __tstate = wxPyBeginAllowThreads();
28261 result = (wxPyApp *)wxPyGetApp();
28262 wxPyEndAllowThreads(__tstate);
28263 if (PyErr_Occurred()) SWIG_fail;
28264 }
28265 {
28266 resultobj = wxPyMake_wxObject(result, 0);
28267 }
28268 return resultobj;
28269 fail:
28270 return NULL;
28271 }
28272
28273
28274 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28275 PyObject *resultobj = 0;
28276 char *arg1 = (char *) 0 ;
28277 int res1 ;
28278 char *buf1 = 0 ;
28279 int alloc1 = 0 ;
28280 PyObject * obj0 = 0 ;
28281 char * kwnames[] = {
28282 (char *) "encoding", NULL
28283 };
28284
28285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28286 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28287 if (!SWIG_IsOK(res1)) {
28288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28289 }
28290 arg1 = buf1;
28291 {
28292 PyThreadState* __tstate = wxPyBeginAllowThreads();
28293 wxSetDefaultPyEncoding((char const *)arg1);
28294 wxPyEndAllowThreads(__tstate);
28295 if (PyErr_Occurred()) SWIG_fail;
28296 }
28297 resultobj = SWIG_Py_Void();
28298 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28299 return resultobj;
28300 fail:
28301 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28302 return NULL;
28303 }
28304
28305
28306 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28307 PyObject *resultobj = 0;
28308 char *result = 0 ;
28309
28310 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28311 {
28312 PyThreadState* __tstate = wxPyBeginAllowThreads();
28313 result = (char *)wxGetDefaultPyEncoding();
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 resultobj = SWIG_FromCharPtr(result);
28318 return resultobj;
28319 fail:
28320 return NULL;
28321 }
28322
28323
28324 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28325 PyObject *resultobj = 0;
28326 wxEventLoop *result = 0 ;
28327
28328 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28329 {
28330 PyThreadState* __tstate = wxPyBeginAllowThreads();
28331 result = (wxEventLoop *)new wxEventLoop();
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28336 return resultobj;
28337 fail:
28338 return NULL;
28339 }
28340
28341
28342 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28343 PyObject *resultobj = 0;
28344 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28345 void *argp1 = 0 ;
28346 int res1 = 0 ;
28347 PyObject *swig_obj[1] ;
28348
28349 if (!args) SWIG_fail;
28350 swig_obj[0] = args;
28351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28352 if (!SWIG_IsOK(res1)) {
28353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28354 }
28355 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28356 {
28357 PyThreadState* __tstate = wxPyBeginAllowThreads();
28358 delete arg1;
28359
28360 wxPyEndAllowThreads(__tstate);
28361 if (PyErr_Occurred()) SWIG_fail;
28362 }
28363 resultobj = SWIG_Py_Void();
28364 return resultobj;
28365 fail:
28366 return NULL;
28367 }
28368
28369
28370 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28371 PyObject *resultobj = 0;
28372 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28373 int result;
28374 void *argp1 = 0 ;
28375 int res1 = 0 ;
28376 PyObject *swig_obj[1] ;
28377
28378 if (!args) SWIG_fail;
28379 swig_obj[0] = args;
28380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28381 if (!SWIG_IsOK(res1)) {
28382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28383 }
28384 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28385 {
28386 PyThreadState* __tstate = wxPyBeginAllowThreads();
28387 result = (int)(arg1)->Run();
28388 wxPyEndAllowThreads(__tstate);
28389 if (PyErr_Occurred()) SWIG_fail;
28390 }
28391 resultobj = SWIG_From_int(static_cast< int >(result));
28392 return resultobj;
28393 fail:
28394 return NULL;
28395 }
28396
28397
28398 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28399 PyObject *resultobj = 0;
28400 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28401 int arg2 = (int) 0 ;
28402 void *argp1 = 0 ;
28403 int res1 = 0 ;
28404 int val2 ;
28405 int ecode2 = 0 ;
28406 PyObject * obj0 = 0 ;
28407 PyObject * obj1 = 0 ;
28408 char * kwnames[] = {
28409 (char *) "self",(char *) "rc", NULL
28410 };
28411
28412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28414 if (!SWIG_IsOK(res1)) {
28415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28416 }
28417 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28418 if (obj1) {
28419 ecode2 = SWIG_AsVal_int(obj1, &val2);
28420 if (!SWIG_IsOK(ecode2)) {
28421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28422 }
28423 arg2 = static_cast< int >(val2);
28424 }
28425 {
28426 PyThreadState* __tstate = wxPyBeginAllowThreads();
28427 (arg1)->Exit(arg2);
28428 wxPyEndAllowThreads(__tstate);
28429 if (PyErr_Occurred()) SWIG_fail;
28430 }
28431 resultobj = SWIG_Py_Void();
28432 return resultobj;
28433 fail:
28434 return NULL;
28435 }
28436
28437
28438 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28439 PyObject *resultobj = 0;
28440 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28441 bool result;
28442 void *argp1 = 0 ;
28443 int res1 = 0 ;
28444 PyObject *swig_obj[1] ;
28445
28446 if (!args) SWIG_fail;
28447 swig_obj[0] = args;
28448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28449 if (!SWIG_IsOK(res1)) {
28450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28451 }
28452 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28453 {
28454 PyThreadState* __tstate = wxPyBeginAllowThreads();
28455 result = (bool)((wxEventLoop const *)arg1)->Pending();
28456 wxPyEndAllowThreads(__tstate);
28457 if (PyErr_Occurred()) SWIG_fail;
28458 }
28459 {
28460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28461 }
28462 return resultobj;
28463 fail:
28464 return NULL;
28465 }
28466
28467
28468 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28469 PyObject *resultobj = 0;
28470 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28471 bool result;
28472 void *argp1 = 0 ;
28473 int res1 = 0 ;
28474 PyObject *swig_obj[1] ;
28475
28476 if (!args) SWIG_fail;
28477 swig_obj[0] = args;
28478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28479 if (!SWIG_IsOK(res1)) {
28480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28481 }
28482 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28483 {
28484 PyThreadState* __tstate = wxPyBeginAllowThreads();
28485 result = (bool)(arg1)->Dispatch();
28486 wxPyEndAllowThreads(__tstate);
28487 if (PyErr_Occurred()) SWIG_fail;
28488 }
28489 {
28490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28491 }
28492 return resultobj;
28493 fail:
28494 return NULL;
28495 }
28496
28497
28498 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28499 PyObject *resultobj = 0;
28500 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28501 bool result;
28502 void *argp1 = 0 ;
28503 int res1 = 0 ;
28504 PyObject *swig_obj[1] ;
28505
28506 if (!args) SWIG_fail;
28507 swig_obj[0] = args;
28508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28509 if (!SWIG_IsOK(res1)) {
28510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28511 }
28512 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28513 {
28514 PyThreadState* __tstate = wxPyBeginAllowThreads();
28515 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28516 wxPyEndAllowThreads(__tstate);
28517 if (PyErr_Occurred()) SWIG_fail;
28518 }
28519 {
28520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28521 }
28522 return resultobj;
28523 fail:
28524 return NULL;
28525 }
28526
28527
28528 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28529 PyObject *resultobj = 0;
28530 wxEventLoop *result = 0 ;
28531
28532 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28533 {
28534 PyThreadState* __tstate = wxPyBeginAllowThreads();
28535 result = (wxEventLoop *)wxEventLoop::GetActive();
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28540 return resultobj;
28541 fail:
28542 return NULL;
28543 }
28544
28545
28546 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28547 PyObject *resultobj = 0;
28548 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28549 void *argp1 = 0 ;
28550 int res1 = 0 ;
28551 PyObject * obj0 = 0 ;
28552 char * kwnames[] = {
28553 (char *) "loop", NULL
28554 };
28555
28556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28558 if (!SWIG_IsOK(res1)) {
28559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28560 }
28561 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28562 {
28563 PyThreadState* __tstate = wxPyBeginAllowThreads();
28564 wxEventLoop::SetActive(arg1);
28565 wxPyEndAllowThreads(__tstate);
28566 if (PyErr_Occurred()) SWIG_fail;
28567 }
28568 resultobj = SWIG_Py_Void();
28569 return resultobj;
28570 fail:
28571 return NULL;
28572 }
28573
28574
28575 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28576 PyObject *obj;
28577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28578 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28579 return SWIG_Py_Void();
28580 }
28581
28582 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28583 return SWIG_Python_InitShadowInstance(args);
28584 }
28585
28586 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28587 PyObject *resultobj = 0;
28588 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28589 wxEventLoopActivator *result = 0 ;
28590 void *argp1 = 0 ;
28591 int res1 = 0 ;
28592 PyObject * obj0 = 0 ;
28593 char * kwnames[] = {
28594 (char *) "evtLoop", NULL
28595 };
28596
28597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28599 if (!SWIG_IsOK(res1)) {
28600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28601 }
28602 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28603 {
28604 PyThreadState* __tstate = wxPyBeginAllowThreads();
28605 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28617 PyObject *resultobj = 0;
28618 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28619 void *argp1 = 0 ;
28620 int res1 = 0 ;
28621 PyObject *swig_obj[1] ;
28622
28623 if (!args) SWIG_fail;
28624 swig_obj[0] = args;
28625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28626 if (!SWIG_IsOK(res1)) {
28627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28628 }
28629 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28630 {
28631 PyThreadState* __tstate = wxPyBeginAllowThreads();
28632 delete arg1;
28633
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 resultobj = SWIG_Py_Void();
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28645 PyObject *obj;
28646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28647 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28648 return SWIG_Py_Void();
28649 }
28650
28651 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28652 return SWIG_Python_InitShadowInstance(args);
28653 }
28654
28655 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28656 PyObject *resultobj = 0;
28657 int arg1 = (int) 0 ;
28658 int arg2 = (int) 0 ;
28659 int arg3 = (int) 0 ;
28660 wxAcceleratorEntry *result = 0 ;
28661 int val1 ;
28662 int ecode1 = 0 ;
28663 int val2 ;
28664 int ecode2 = 0 ;
28665 int val3 ;
28666 int ecode3 = 0 ;
28667 PyObject * obj0 = 0 ;
28668 PyObject * obj1 = 0 ;
28669 PyObject * obj2 = 0 ;
28670 char * kwnames[] = {
28671 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28672 };
28673
28674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28675 if (obj0) {
28676 ecode1 = SWIG_AsVal_int(obj0, &val1);
28677 if (!SWIG_IsOK(ecode1)) {
28678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28679 }
28680 arg1 = static_cast< int >(val1);
28681 }
28682 if (obj1) {
28683 ecode2 = SWIG_AsVal_int(obj1, &val2);
28684 if (!SWIG_IsOK(ecode2)) {
28685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28686 }
28687 arg2 = static_cast< int >(val2);
28688 }
28689 if (obj2) {
28690 ecode3 = SWIG_AsVal_int(obj2, &val3);
28691 if (!SWIG_IsOK(ecode3)) {
28692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28693 }
28694 arg3 = static_cast< int >(val3);
28695 }
28696 {
28697 PyThreadState* __tstate = wxPyBeginAllowThreads();
28698 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28699 wxPyEndAllowThreads(__tstate);
28700 if (PyErr_Occurred()) SWIG_fail;
28701 }
28702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28703 return resultobj;
28704 fail:
28705 return NULL;
28706 }
28707
28708
28709 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28710 PyObject *resultobj = 0;
28711 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28712 void *argp1 = 0 ;
28713 int res1 = 0 ;
28714 PyObject *swig_obj[1] ;
28715
28716 if (!args) SWIG_fail;
28717 swig_obj[0] = args;
28718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28719 if (!SWIG_IsOK(res1)) {
28720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28721 }
28722 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28723 {
28724 PyThreadState* __tstate = wxPyBeginAllowThreads();
28725 delete arg1;
28726
28727 wxPyEndAllowThreads(__tstate);
28728 if (PyErr_Occurred()) SWIG_fail;
28729 }
28730 resultobj = SWIG_Py_Void();
28731 return resultobj;
28732 fail:
28733 return NULL;
28734 }
28735
28736
28737 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28738 PyObject *resultobj = 0;
28739 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28740 int arg2 ;
28741 int arg3 ;
28742 int arg4 ;
28743 void *argp1 = 0 ;
28744 int res1 = 0 ;
28745 int val2 ;
28746 int ecode2 = 0 ;
28747 int val3 ;
28748 int ecode3 = 0 ;
28749 int val4 ;
28750 int ecode4 = 0 ;
28751 PyObject * obj0 = 0 ;
28752 PyObject * obj1 = 0 ;
28753 PyObject * obj2 = 0 ;
28754 PyObject * obj3 = 0 ;
28755 char * kwnames[] = {
28756 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28757 };
28758
28759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28761 if (!SWIG_IsOK(res1)) {
28762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28763 }
28764 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28765 ecode2 = SWIG_AsVal_int(obj1, &val2);
28766 if (!SWIG_IsOK(ecode2)) {
28767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28768 }
28769 arg2 = static_cast< int >(val2);
28770 ecode3 = SWIG_AsVal_int(obj2, &val3);
28771 if (!SWIG_IsOK(ecode3)) {
28772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28773 }
28774 arg3 = static_cast< int >(val3);
28775 ecode4 = SWIG_AsVal_int(obj3, &val4);
28776 if (!SWIG_IsOK(ecode4)) {
28777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28778 }
28779 arg4 = static_cast< int >(val4);
28780 {
28781 PyThreadState* __tstate = wxPyBeginAllowThreads();
28782 (arg1)->Set(arg2,arg3,arg4);
28783 wxPyEndAllowThreads(__tstate);
28784 if (PyErr_Occurred()) SWIG_fail;
28785 }
28786 resultobj = SWIG_Py_Void();
28787 return resultobj;
28788 fail:
28789 return NULL;
28790 }
28791
28792
28793 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28794 PyObject *resultobj = 0;
28795 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28796 int result;
28797 void *argp1 = 0 ;
28798 int res1 = 0 ;
28799 PyObject *swig_obj[1] ;
28800
28801 if (!args) SWIG_fail;
28802 swig_obj[0] = args;
28803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28804 if (!SWIG_IsOK(res1)) {
28805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28806 }
28807 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28808 {
28809 PyThreadState* __tstate = wxPyBeginAllowThreads();
28810 result = (int)(arg1)->GetFlags();
28811 wxPyEndAllowThreads(__tstate);
28812 if (PyErr_Occurred()) SWIG_fail;
28813 }
28814 resultobj = SWIG_From_int(static_cast< int >(result));
28815 return resultobj;
28816 fail:
28817 return NULL;
28818 }
28819
28820
28821 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28822 PyObject *resultobj = 0;
28823 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28824 int result;
28825 void *argp1 = 0 ;
28826 int res1 = 0 ;
28827 PyObject *swig_obj[1] ;
28828
28829 if (!args) SWIG_fail;
28830 swig_obj[0] = args;
28831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28832 if (!SWIG_IsOK(res1)) {
28833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28834 }
28835 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28836 {
28837 PyThreadState* __tstate = wxPyBeginAllowThreads();
28838 result = (int)(arg1)->GetKeyCode();
28839 wxPyEndAllowThreads(__tstate);
28840 if (PyErr_Occurred()) SWIG_fail;
28841 }
28842 resultobj = SWIG_From_int(static_cast< int >(result));
28843 return resultobj;
28844 fail:
28845 return NULL;
28846 }
28847
28848
28849 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28850 PyObject *resultobj = 0;
28851 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28852 int result;
28853 void *argp1 = 0 ;
28854 int res1 = 0 ;
28855 PyObject *swig_obj[1] ;
28856
28857 if (!args) SWIG_fail;
28858 swig_obj[0] = args;
28859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28860 if (!SWIG_IsOK(res1)) {
28861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28862 }
28863 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28864 {
28865 PyThreadState* __tstate = wxPyBeginAllowThreads();
28866 result = (int)(arg1)->GetCommand();
28867 wxPyEndAllowThreads(__tstate);
28868 if (PyErr_Occurred()) SWIG_fail;
28869 }
28870 resultobj = SWIG_From_int(static_cast< int >(result));
28871 return resultobj;
28872 fail:
28873 return NULL;
28874 }
28875
28876
28877 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28878 PyObject *obj;
28879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28880 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28881 return SWIG_Py_Void();
28882 }
28883
28884 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28885 return SWIG_Python_InitShadowInstance(args);
28886 }
28887
28888 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28889 PyObject *resultobj = 0;
28890 int arg1 ;
28891 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28892 wxAcceleratorTable *result = 0 ;
28893 PyObject * obj0 = 0 ;
28894 char * kwnames[] = {
28895 (char *) "n", NULL
28896 };
28897
28898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28899 {
28900 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28901 if (arg2) arg1 = PyList_Size(obj0);
28902 else arg1 = 0;
28903 }
28904 {
28905 PyThreadState* __tstate = wxPyBeginAllowThreads();
28906 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28907 wxPyEndAllowThreads(__tstate);
28908 if (PyErr_Occurred()) SWIG_fail;
28909 }
28910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
28911 return resultobj;
28912 fail:
28913 return NULL;
28914 }
28915
28916
28917 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28918 PyObject *resultobj = 0;
28919 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28920 void *argp1 = 0 ;
28921 int res1 = 0 ;
28922 PyObject *swig_obj[1] ;
28923
28924 if (!args) SWIG_fail;
28925 swig_obj[0] = args;
28926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
28927 if (!SWIG_IsOK(res1)) {
28928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
28929 }
28930 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28931 {
28932 PyThreadState* __tstate = wxPyBeginAllowThreads();
28933 delete arg1;
28934
28935 wxPyEndAllowThreads(__tstate);
28936 if (PyErr_Occurred()) SWIG_fail;
28937 }
28938 resultobj = SWIG_Py_Void();
28939 return resultobj;
28940 fail:
28941 return NULL;
28942 }
28943
28944
28945 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28946 PyObject *resultobj = 0;
28947 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28948 bool result;
28949 void *argp1 = 0 ;
28950 int res1 = 0 ;
28951 PyObject *swig_obj[1] ;
28952
28953 if (!args) SWIG_fail;
28954 swig_obj[0] = args;
28955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
28956 if (!SWIG_IsOK(res1)) {
28957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
28958 }
28959 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28960 {
28961 PyThreadState* __tstate = wxPyBeginAllowThreads();
28962 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
28963 wxPyEndAllowThreads(__tstate);
28964 if (PyErr_Occurred()) SWIG_fail;
28965 }
28966 {
28967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28968 }
28969 return resultobj;
28970 fail:
28971 return NULL;
28972 }
28973
28974
28975 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28976 PyObject *obj;
28977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28978 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
28979 return SWIG_Py_Void();
28980 }
28981
28982 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28983 return SWIG_Python_InitShadowInstance(args);
28984 }
28985
28986 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
28987 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
28988 return 1;
28989 }
28990
28991
28992 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
28993 PyObject *pyobj = 0;
28994
28995 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
28996 return pyobj;
28997 }
28998
28999
29000 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29001 PyObject *resultobj = 0;
29002 wxString *arg1 = 0 ;
29003 wxAcceleratorEntry *result = 0 ;
29004 bool temp1 = false ;
29005 PyObject * obj0 = 0 ;
29006 char * kwnames[] = {
29007 (char *) "label", NULL
29008 };
29009
29010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29011 {
29012 arg1 = wxString_in_helper(obj0);
29013 if (arg1 == NULL) SWIG_fail;
29014 temp1 = true;
29015 }
29016 {
29017 PyThreadState* __tstate = wxPyBeginAllowThreads();
29018 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29019 wxPyEndAllowThreads(__tstate);
29020 if (PyErr_Occurred()) SWIG_fail;
29021 }
29022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29023 {
29024 if (temp1)
29025 delete arg1;
29026 }
29027 return resultobj;
29028 fail:
29029 {
29030 if (temp1)
29031 delete arg1;
29032 }
29033 return NULL;
29034 }
29035
29036
29037 SWIGINTERN int PanelNameStr_set(PyObject *) {
29038 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29039 return 1;
29040 }
29041
29042
29043 SWIGINTERN PyObject *PanelNameStr_get(void) {
29044 PyObject *pyobj = 0;
29045
29046 {
29047 #if wxUSE_UNICODE
29048 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29049 #else
29050 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29051 #endif
29052 }
29053 return pyobj;
29054 }
29055
29056
29057 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29058 PyObject *resultobj = 0;
29059 wxVisualAttributes *result = 0 ;
29060
29061 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29062 {
29063 PyThreadState* __tstate = wxPyBeginAllowThreads();
29064 result = (wxVisualAttributes *)new_wxVisualAttributes();
29065 wxPyEndAllowThreads(__tstate);
29066 if (PyErr_Occurred()) SWIG_fail;
29067 }
29068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29069 return resultobj;
29070 fail:
29071 return NULL;
29072 }
29073
29074
29075 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29076 PyObject *resultobj = 0;
29077 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29078 void *argp1 = 0 ;
29079 int res1 = 0 ;
29080 PyObject *swig_obj[1] ;
29081
29082 if (!args) SWIG_fail;
29083 swig_obj[0] = args;
29084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29085 if (!SWIG_IsOK(res1)) {
29086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29087 }
29088 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29089 {
29090 PyThreadState* __tstate = wxPyBeginAllowThreads();
29091 delete_wxVisualAttributes(arg1);
29092
29093 wxPyEndAllowThreads(__tstate);
29094 if (PyErr_Occurred()) SWIG_fail;
29095 }
29096 resultobj = SWIG_Py_Void();
29097 return resultobj;
29098 fail:
29099 return NULL;
29100 }
29101
29102
29103 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29104 PyObject *resultobj = 0;
29105 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29106 wxFont *arg2 = (wxFont *) 0 ;
29107 void *argp1 = 0 ;
29108 int res1 = 0 ;
29109 void *argp2 = 0 ;
29110 int res2 = 0 ;
29111 PyObject *swig_obj[2] ;
29112
29113 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29115 if (!SWIG_IsOK(res1)) {
29116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29117 }
29118 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29119 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29120 if (!SWIG_IsOK(res2)) {
29121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29122 }
29123 arg2 = reinterpret_cast< wxFont * >(argp2);
29124 if (arg1) (arg1)->font = *arg2;
29125
29126 resultobj = SWIG_Py_Void();
29127 return resultobj;
29128 fail:
29129 return NULL;
29130 }
29131
29132
29133 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29134 PyObject *resultobj = 0;
29135 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29136 wxFont *result = 0 ;
29137 void *argp1 = 0 ;
29138 int res1 = 0 ;
29139 PyObject *swig_obj[1] ;
29140
29141 if (!args) SWIG_fail;
29142 swig_obj[0] = args;
29143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29144 if (!SWIG_IsOK(res1)) {
29145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29146 }
29147 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29148 result = (wxFont *)& ((arg1)->font);
29149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29150 return resultobj;
29151 fail:
29152 return NULL;
29153 }
29154
29155
29156 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29157 PyObject *resultobj = 0;
29158 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29159 wxColour *arg2 = (wxColour *) 0 ;
29160 void *argp1 = 0 ;
29161 int res1 = 0 ;
29162 void *argp2 = 0 ;
29163 int res2 = 0 ;
29164 PyObject *swig_obj[2] ;
29165
29166 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29168 if (!SWIG_IsOK(res1)) {
29169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29170 }
29171 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29172 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29173 if (!SWIG_IsOK(res2)) {
29174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29175 }
29176 arg2 = reinterpret_cast< wxColour * >(argp2);
29177 if (arg1) (arg1)->colFg = *arg2;
29178
29179 resultobj = SWIG_Py_Void();
29180 return resultobj;
29181 fail:
29182 return NULL;
29183 }
29184
29185
29186 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29187 PyObject *resultobj = 0;
29188 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29189 wxColour *result = 0 ;
29190 void *argp1 = 0 ;
29191 int res1 = 0 ;
29192 PyObject *swig_obj[1] ;
29193
29194 if (!args) SWIG_fail;
29195 swig_obj[0] = args;
29196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29197 if (!SWIG_IsOK(res1)) {
29198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29199 }
29200 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29201 result = (wxColour *)& ((arg1)->colFg);
29202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29203 return resultobj;
29204 fail:
29205 return NULL;
29206 }
29207
29208
29209 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29210 PyObject *resultobj = 0;
29211 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29212 wxColour *arg2 = (wxColour *) 0 ;
29213 void *argp1 = 0 ;
29214 int res1 = 0 ;
29215 void *argp2 = 0 ;
29216 int res2 = 0 ;
29217 PyObject *swig_obj[2] ;
29218
29219 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29221 if (!SWIG_IsOK(res1)) {
29222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29223 }
29224 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29225 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29226 if (!SWIG_IsOK(res2)) {
29227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29228 }
29229 arg2 = reinterpret_cast< wxColour * >(argp2);
29230 if (arg1) (arg1)->colBg = *arg2;
29231
29232 resultobj = SWIG_Py_Void();
29233 return resultobj;
29234 fail:
29235 return NULL;
29236 }
29237
29238
29239 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29240 PyObject *resultobj = 0;
29241 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29242 wxColour *result = 0 ;
29243 void *argp1 = 0 ;
29244 int res1 = 0 ;
29245 PyObject *swig_obj[1] ;
29246
29247 if (!args) SWIG_fail;
29248 swig_obj[0] = args;
29249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29250 if (!SWIG_IsOK(res1)) {
29251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29252 }
29253 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29254 result = (wxColour *)& ((arg1)->colBg);
29255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29256 return resultobj;
29257 fail:
29258 return NULL;
29259 }
29260
29261
29262 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29263 PyObject *obj;
29264 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29265 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29266 return SWIG_Py_Void();
29267 }
29268
29269 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29270 return SWIG_Python_InitShadowInstance(args);
29271 }
29272
29273 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29274 PyObject *resultobj = 0;
29275 wxWindow *arg1 = (wxWindow *) 0 ;
29276 int arg2 = (int) (int)-1 ;
29277 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29278 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29279 wxSize const &arg4_defvalue = wxDefaultSize ;
29280 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29281 long arg5 = (long) 0 ;
29282 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29283 wxString *arg6 = (wxString *) &arg6_defvalue ;
29284 wxWindow *result = 0 ;
29285 void *argp1 = 0 ;
29286 int res1 = 0 ;
29287 int val2 ;
29288 int ecode2 = 0 ;
29289 wxPoint temp3 ;
29290 wxSize temp4 ;
29291 long val5 ;
29292 int ecode5 = 0 ;
29293 bool temp6 = false ;
29294 PyObject * obj0 = 0 ;
29295 PyObject * obj1 = 0 ;
29296 PyObject * obj2 = 0 ;
29297 PyObject * obj3 = 0 ;
29298 PyObject * obj4 = 0 ;
29299 PyObject * obj5 = 0 ;
29300 char * kwnames[] = {
29301 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29302 };
29303
29304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29306 if (!SWIG_IsOK(res1)) {
29307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29308 }
29309 arg1 = reinterpret_cast< wxWindow * >(argp1);
29310 if (obj1) {
29311 ecode2 = SWIG_AsVal_int(obj1, &val2);
29312 if (!SWIG_IsOK(ecode2)) {
29313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29314 }
29315 arg2 = static_cast< int >(val2);
29316 }
29317 if (obj2) {
29318 {
29319 arg3 = &temp3;
29320 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29321 }
29322 }
29323 if (obj3) {
29324 {
29325 arg4 = &temp4;
29326 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29327 }
29328 }
29329 if (obj4) {
29330 ecode5 = SWIG_AsVal_long(obj4, &val5);
29331 if (!SWIG_IsOK(ecode5)) {
29332 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29333 }
29334 arg5 = static_cast< long >(val5);
29335 }
29336 if (obj5) {
29337 {
29338 arg6 = wxString_in_helper(obj5);
29339 if (arg6 == NULL) SWIG_fail;
29340 temp6 = true;
29341 }
29342 }
29343 {
29344 if (!wxPyCheckForApp()) SWIG_fail;
29345 PyThreadState* __tstate = wxPyBeginAllowThreads();
29346 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29347 wxPyEndAllowThreads(__tstate);
29348 if (PyErr_Occurred()) SWIG_fail;
29349 }
29350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29351 {
29352 if (temp6)
29353 delete arg6;
29354 }
29355 return resultobj;
29356 fail:
29357 {
29358 if (temp6)
29359 delete arg6;
29360 }
29361 return NULL;
29362 }
29363
29364
29365 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29366 PyObject *resultobj = 0;
29367 wxWindow *result = 0 ;
29368
29369 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29370 {
29371 if (!wxPyCheckForApp()) SWIG_fail;
29372 PyThreadState* __tstate = wxPyBeginAllowThreads();
29373 result = (wxWindow *)new wxWindow();
29374 wxPyEndAllowThreads(__tstate);
29375 if (PyErr_Occurred()) SWIG_fail;
29376 }
29377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29378 return resultobj;
29379 fail:
29380 return NULL;
29381 }
29382
29383
29384 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29385 PyObject *resultobj = 0;
29386 wxWindow *arg1 = (wxWindow *) 0 ;
29387 wxWindow *arg2 = (wxWindow *) 0 ;
29388 int arg3 = (int) (int)-1 ;
29389 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29390 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29391 wxSize const &arg5_defvalue = wxDefaultSize ;
29392 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29393 long arg6 = (long) 0 ;
29394 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29395 wxString *arg7 = (wxString *) &arg7_defvalue ;
29396 bool result;
29397 void *argp1 = 0 ;
29398 int res1 = 0 ;
29399 void *argp2 = 0 ;
29400 int res2 = 0 ;
29401 int val3 ;
29402 int ecode3 = 0 ;
29403 wxPoint temp4 ;
29404 wxSize temp5 ;
29405 long val6 ;
29406 int ecode6 = 0 ;
29407 bool temp7 = false ;
29408 PyObject * obj0 = 0 ;
29409 PyObject * obj1 = 0 ;
29410 PyObject * obj2 = 0 ;
29411 PyObject * obj3 = 0 ;
29412 PyObject * obj4 = 0 ;
29413 PyObject * obj5 = 0 ;
29414 PyObject * obj6 = 0 ;
29415 char * kwnames[] = {
29416 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29417 };
29418
29419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29421 if (!SWIG_IsOK(res1)) {
29422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29423 }
29424 arg1 = reinterpret_cast< wxWindow * >(argp1);
29425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29426 if (!SWIG_IsOK(res2)) {
29427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29428 }
29429 arg2 = reinterpret_cast< wxWindow * >(argp2);
29430 if (obj2) {
29431 ecode3 = SWIG_AsVal_int(obj2, &val3);
29432 if (!SWIG_IsOK(ecode3)) {
29433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29434 }
29435 arg3 = static_cast< int >(val3);
29436 }
29437 if (obj3) {
29438 {
29439 arg4 = &temp4;
29440 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29441 }
29442 }
29443 if (obj4) {
29444 {
29445 arg5 = &temp5;
29446 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29447 }
29448 }
29449 if (obj5) {
29450 ecode6 = SWIG_AsVal_long(obj5, &val6);
29451 if (!SWIG_IsOK(ecode6)) {
29452 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29453 }
29454 arg6 = static_cast< long >(val6);
29455 }
29456 if (obj6) {
29457 {
29458 arg7 = wxString_in_helper(obj6);
29459 if (arg7 == NULL) SWIG_fail;
29460 temp7 = true;
29461 }
29462 }
29463 {
29464 PyThreadState* __tstate = wxPyBeginAllowThreads();
29465 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29466 wxPyEndAllowThreads(__tstate);
29467 if (PyErr_Occurred()) SWIG_fail;
29468 }
29469 {
29470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29471 }
29472 {
29473 if (temp7)
29474 delete arg7;
29475 }
29476 return resultobj;
29477 fail:
29478 {
29479 if (temp7)
29480 delete arg7;
29481 }
29482 return NULL;
29483 }
29484
29485
29486 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29487 PyObject *resultobj = 0;
29488 wxWindow *arg1 = (wxWindow *) 0 ;
29489 bool arg2 = (bool) false ;
29490 bool result;
29491 void *argp1 = 0 ;
29492 int res1 = 0 ;
29493 bool val2 ;
29494 int ecode2 = 0 ;
29495 PyObject * obj0 = 0 ;
29496 PyObject * obj1 = 0 ;
29497 char * kwnames[] = {
29498 (char *) "self",(char *) "force", NULL
29499 };
29500
29501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29503 if (!SWIG_IsOK(res1)) {
29504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29505 }
29506 arg1 = reinterpret_cast< wxWindow * >(argp1);
29507 if (obj1) {
29508 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29509 if (!SWIG_IsOK(ecode2)) {
29510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29511 }
29512 arg2 = static_cast< bool >(val2);
29513 }
29514 {
29515 PyThreadState* __tstate = wxPyBeginAllowThreads();
29516 result = (bool)(arg1)->Close(arg2);
29517 wxPyEndAllowThreads(__tstate);
29518 if (PyErr_Occurred()) SWIG_fail;
29519 }
29520 {
29521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29522 }
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29530 PyObject *resultobj = 0;
29531 wxWindow *arg1 = (wxWindow *) 0 ;
29532 bool result;
29533 void *argp1 = 0 ;
29534 int res1 = 0 ;
29535 PyObject *swig_obj[1] ;
29536
29537 if (!args) SWIG_fail;
29538 swig_obj[0] = args;
29539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29540 if (!SWIG_IsOK(res1)) {
29541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29542 }
29543 arg1 = reinterpret_cast< wxWindow * >(argp1);
29544 {
29545 PyThreadState* __tstate = wxPyBeginAllowThreads();
29546 result = (bool)(arg1)->Destroy();
29547 wxPyEndAllowThreads(__tstate);
29548 if (PyErr_Occurred()) SWIG_fail;
29549 }
29550 {
29551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29552 }
29553 return resultobj;
29554 fail:
29555 return NULL;
29556 }
29557
29558
29559 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29560 PyObject *resultobj = 0;
29561 wxWindow *arg1 = (wxWindow *) 0 ;
29562 bool result;
29563 void *argp1 = 0 ;
29564 int res1 = 0 ;
29565 PyObject *swig_obj[1] ;
29566
29567 if (!args) SWIG_fail;
29568 swig_obj[0] = args;
29569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29570 if (!SWIG_IsOK(res1)) {
29571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29572 }
29573 arg1 = reinterpret_cast< wxWindow * >(argp1);
29574 {
29575 PyThreadState* __tstate = wxPyBeginAllowThreads();
29576 result = (bool)(arg1)->DestroyChildren();
29577 wxPyEndAllowThreads(__tstate);
29578 if (PyErr_Occurred()) SWIG_fail;
29579 }
29580 {
29581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29582 }
29583 return resultobj;
29584 fail:
29585 return NULL;
29586 }
29587
29588
29589 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29590 PyObject *resultobj = 0;
29591 wxWindow *arg1 = (wxWindow *) 0 ;
29592 bool result;
29593 void *argp1 = 0 ;
29594 int res1 = 0 ;
29595 PyObject *swig_obj[1] ;
29596
29597 if (!args) SWIG_fail;
29598 swig_obj[0] = args;
29599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29600 if (!SWIG_IsOK(res1)) {
29601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29602 }
29603 arg1 = reinterpret_cast< wxWindow * >(argp1);
29604 {
29605 PyThreadState* __tstate = wxPyBeginAllowThreads();
29606 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29607 wxPyEndAllowThreads(__tstate);
29608 if (PyErr_Occurred()) SWIG_fail;
29609 }
29610 {
29611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29612 }
29613 return resultobj;
29614 fail:
29615 return NULL;
29616 }
29617
29618
29619 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29620 PyObject *resultobj = 0;
29621 wxWindow *arg1 = (wxWindow *) 0 ;
29622 wxString *arg2 = 0 ;
29623 void *argp1 = 0 ;
29624 int res1 = 0 ;
29625 bool temp2 = false ;
29626 PyObject * obj0 = 0 ;
29627 PyObject * obj1 = 0 ;
29628 char * kwnames[] = {
29629 (char *) "self",(char *) "label", NULL
29630 };
29631
29632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29634 if (!SWIG_IsOK(res1)) {
29635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29636 }
29637 arg1 = reinterpret_cast< wxWindow * >(argp1);
29638 {
29639 arg2 = wxString_in_helper(obj1);
29640 if (arg2 == NULL) SWIG_fail;
29641 temp2 = true;
29642 }
29643 {
29644 PyThreadState* __tstate = wxPyBeginAllowThreads();
29645 (arg1)->SetLabel((wxString const &)*arg2);
29646 wxPyEndAllowThreads(__tstate);
29647 if (PyErr_Occurred()) SWIG_fail;
29648 }
29649 resultobj = SWIG_Py_Void();
29650 {
29651 if (temp2)
29652 delete arg2;
29653 }
29654 return resultobj;
29655 fail:
29656 {
29657 if (temp2)
29658 delete arg2;
29659 }
29660 return NULL;
29661 }
29662
29663
29664 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29665 PyObject *resultobj = 0;
29666 wxWindow *arg1 = (wxWindow *) 0 ;
29667 wxString result;
29668 void *argp1 = 0 ;
29669 int res1 = 0 ;
29670 PyObject *swig_obj[1] ;
29671
29672 if (!args) SWIG_fail;
29673 swig_obj[0] = args;
29674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29675 if (!SWIG_IsOK(res1)) {
29676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29677 }
29678 arg1 = reinterpret_cast< wxWindow * >(argp1);
29679 {
29680 PyThreadState* __tstate = wxPyBeginAllowThreads();
29681 result = ((wxWindow const *)arg1)->GetLabel();
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 {
29686 #if wxUSE_UNICODE
29687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29688 #else
29689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29690 #endif
29691 }
29692 return resultobj;
29693 fail:
29694 return NULL;
29695 }
29696
29697
29698 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29699 PyObject *resultobj = 0;
29700 wxWindow *arg1 = (wxWindow *) 0 ;
29701 wxString *arg2 = 0 ;
29702 void *argp1 = 0 ;
29703 int res1 = 0 ;
29704 bool temp2 = false ;
29705 PyObject * obj0 = 0 ;
29706 PyObject * obj1 = 0 ;
29707 char * kwnames[] = {
29708 (char *) "self",(char *) "name", NULL
29709 };
29710
29711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29713 if (!SWIG_IsOK(res1)) {
29714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29715 }
29716 arg1 = reinterpret_cast< wxWindow * >(argp1);
29717 {
29718 arg2 = wxString_in_helper(obj1);
29719 if (arg2 == NULL) SWIG_fail;
29720 temp2 = true;
29721 }
29722 {
29723 PyThreadState* __tstate = wxPyBeginAllowThreads();
29724 (arg1)->SetName((wxString const &)*arg2);
29725 wxPyEndAllowThreads(__tstate);
29726 if (PyErr_Occurred()) SWIG_fail;
29727 }
29728 resultobj = SWIG_Py_Void();
29729 {
29730 if (temp2)
29731 delete arg2;
29732 }
29733 return resultobj;
29734 fail:
29735 {
29736 if (temp2)
29737 delete arg2;
29738 }
29739 return NULL;
29740 }
29741
29742
29743 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29744 PyObject *resultobj = 0;
29745 wxWindow *arg1 = (wxWindow *) 0 ;
29746 wxString result;
29747 void *argp1 = 0 ;
29748 int res1 = 0 ;
29749 PyObject *swig_obj[1] ;
29750
29751 if (!args) SWIG_fail;
29752 swig_obj[0] = args;
29753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29754 if (!SWIG_IsOK(res1)) {
29755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29756 }
29757 arg1 = reinterpret_cast< wxWindow * >(argp1);
29758 {
29759 PyThreadState* __tstate = wxPyBeginAllowThreads();
29760 result = ((wxWindow const *)arg1)->GetName();
29761 wxPyEndAllowThreads(__tstate);
29762 if (PyErr_Occurred()) SWIG_fail;
29763 }
29764 {
29765 #if wxUSE_UNICODE
29766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29767 #else
29768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29769 #endif
29770 }
29771 return resultobj;
29772 fail:
29773 return NULL;
29774 }
29775
29776
29777 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29778 PyObject *resultobj = 0;
29779 wxWindow *arg1 = (wxWindow *) 0 ;
29780 wxWindowVariant arg2 ;
29781 void *argp1 = 0 ;
29782 int res1 = 0 ;
29783 int val2 ;
29784 int ecode2 = 0 ;
29785 PyObject * obj0 = 0 ;
29786 PyObject * obj1 = 0 ;
29787 char * kwnames[] = {
29788 (char *) "self",(char *) "variant", NULL
29789 };
29790
29791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29793 if (!SWIG_IsOK(res1)) {
29794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29795 }
29796 arg1 = reinterpret_cast< wxWindow * >(argp1);
29797 ecode2 = SWIG_AsVal_int(obj1, &val2);
29798 if (!SWIG_IsOK(ecode2)) {
29799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29800 }
29801 arg2 = static_cast< wxWindowVariant >(val2);
29802 {
29803 PyThreadState* __tstate = wxPyBeginAllowThreads();
29804 (arg1)->SetWindowVariant(arg2);
29805 wxPyEndAllowThreads(__tstate);
29806 if (PyErr_Occurred()) SWIG_fail;
29807 }
29808 resultobj = SWIG_Py_Void();
29809 return resultobj;
29810 fail:
29811 return NULL;
29812 }
29813
29814
29815 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29816 PyObject *resultobj = 0;
29817 wxWindow *arg1 = (wxWindow *) 0 ;
29818 wxWindowVariant result;
29819 void *argp1 = 0 ;
29820 int res1 = 0 ;
29821 PyObject *swig_obj[1] ;
29822
29823 if (!args) SWIG_fail;
29824 swig_obj[0] = args;
29825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29826 if (!SWIG_IsOK(res1)) {
29827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29828 }
29829 arg1 = reinterpret_cast< wxWindow * >(argp1);
29830 {
29831 PyThreadState* __tstate = wxPyBeginAllowThreads();
29832 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29833 wxPyEndAllowThreads(__tstate);
29834 if (PyErr_Occurred()) SWIG_fail;
29835 }
29836 resultobj = SWIG_From_int(static_cast< int >(result));
29837 return resultobj;
29838 fail:
29839 return NULL;
29840 }
29841
29842
29843 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29844 PyObject *resultobj = 0;
29845 wxWindow *arg1 = (wxWindow *) 0 ;
29846 int arg2 ;
29847 void *argp1 = 0 ;
29848 int res1 = 0 ;
29849 int val2 ;
29850 int ecode2 = 0 ;
29851 PyObject * obj0 = 0 ;
29852 PyObject * obj1 = 0 ;
29853 char * kwnames[] = {
29854 (char *) "self",(char *) "winid", NULL
29855 };
29856
29857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29859 if (!SWIG_IsOK(res1)) {
29860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29861 }
29862 arg1 = reinterpret_cast< wxWindow * >(argp1);
29863 ecode2 = SWIG_AsVal_int(obj1, &val2);
29864 if (!SWIG_IsOK(ecode2)) {
29865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29866 }
29867 arg2 = static_cast< int >(val2);
29868 {
29869 PyThreadState* __tstate = wxPyBeginAllowThreads();
29870 (arg1)->SetId(arg2);
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 resultobj = SWIG_Py_Void();
29875 return resultobj;
29876 fail:
29877 return NULL;
29878 }
29879
29880
29881 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29882 PyObject *resultobj = 0;
29883 wxWindow *arg1 = (wxWindow *) 0 ;
29884 int result;
29885 void *argp1 = 0 ;
29886 int res1 = 0 ;
29887 PyObject *swig_obj[1] ;
29888
29889 if (!args) SWIG_fail;
29890 swig_obj[0] = args;
29891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29892 if (!SWIG_IsOK(res1)) {
29893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29894 }
29895 arg1 = reinterpret_cast< wxWindow * >(argp1);
29896 {
29897 PyThreadState* __tstate = wxPyBeginAllowThreads();
29898 result = (int)((wxWindow const *)arg1)->GetId();
29899 wxPyEndAllowThreads(__tstate);
29900 if (PyErr_Occurred()) SWIG_fail;
29901 }
29902 resultobj = SWIG_From_int(static_cast< int >(result));
29903 return resultobj;
29904 fail:
29905 return NULL;
29906 }
29907
29908
29909 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29910 PyObject *resultobj = 0;
29911 int result;
29912
29913 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
29914 {
29915 PyThreadState* __tstate = wxPyBeginAllowThreads();
29916 result = (int)wxWindow::NewControlId();
29917 wxPyEndAllowThreads(__tstate);
29918 if (PyErr_Occurred()) SWIG_fail;
29919 }
29920 resultobj = SWIG_From_int(static_cast< int >(result));
29921 return resultobj;
29922 fail:
29923 return NULL;
29924 }
29925
29926
29927 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29928 PyObject *resultobj = 0;
29929 int arg1 ;
29930 int result;
29931 int val1 ;
29932 int ecode1 = 0 ;
29933 PyObject * obj0 = 0 ;
29934 char * kwnames[] = {
29935 (char *) "winid", NULL
29936 };
29937
29938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
29939 ecode1 = SWIG_AsVal_int(obj0, &val1);
29940 if (!SWIG_IsOK(ecode1)) {
29941 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
29942 }
29943 arg1 = static_cast< int >(val1);
29944 {
29945 PyThreadState* __tstate = wxPyBeginAllowThreads();
29946 result = (int)wxWindow::NextControlId(arg1);
29947 wxPyEndAllowThreads(__tstate);
29948 if (PyErr_Occurred()) SWIG_fail;
29949 }
29950 resultobj = SWIG_From_int(static_cast< int >(result));
29951 return resultobj;
29952 fail:
29953 return NULL;
29954 }
29955
29956
29957 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29958 PyObject *resultobj = 0;
29959 int arg1 ;
29960 int result;
29961 int val1 ;
29962 int ecode1 = 0 ;
29963 PyObject * obj0 = 0 ;
29964 char * kwnames[] = {
29965 (char *) "winid", NULL
29966 };
29967
29968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
29969 ecode1 = SWIG_AsVal_int(obj0, &val1);
29970 if (!SWIG_IsOK(ecode1)) {
29971 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
29972 }
29973 arg1 = static_cast< int >(val1);
29974 {
29975 PyThreadState* __tstate = wxPyBeginAllowThreads();
29976 result = (int)wxWindow::PrevControlId(arg1);
29977 wxPyEndAllowThreads(__tstate);
29978 if (PyErr_Occurred()) SWIG_fail;
29979 }
29980 resultobj = SWIG_From_int(static_cast< int >(result));
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29988 PyObject *resultobj = 0;
29989 wxWindow *arg1 = (wxWindow *) 0 ;
29990 wxSize *arg2 = 0 ;
29991 void *argp1 = 0 ;
29992 int res1 = 0 ;
29993 wxSize temp2 ;
29994 PyObject * obj0 = 0 ;
29995 PyObject * obj1 = 0 ;
29996 char * kwnames[] = {
29997 (char *) "self",(char *) "size", NULL
29998 };
29999
30000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30002 if (!SWIG_IsOK(res1)) {
30003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30004 }
30005 arg1 = reinterpret_cast< wxWindow * >(argp1);
30006 {
30007 arg2 = &temp2;
30008 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30009 }
30010 {
30011 PyThreadState* __tstate = wxPyBeginAllowThreads();
30012 (arg1)->SetSize((wxSize const &)*arg2);
30013 wxPyEndAllowThreads(__tstate);
30014 if (PyErr_Occurred()) SWIG_fail;
30015 }
30016 resultobj = SWIG_Py_Void();
30017 return resultobj;
30018 fail:
30019 return NULL;
30020 }
30021
30022
30023 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30024 PyObject *resultobj = 0;
30025 wxWindow *arg1 = (wxWindow *) 0 ;
30026 int arg2 ;
30027 int arg3 ;
30028 int arg4 ;
30029 int arg5 ;
30030 int arg6 = (int) wxSIZE_AUTO ;
30031 void *argp1 = 0 ;
30032 int res1 = 0 ;
30033 int val2 ;
30034 int ecode2 = 0 ;
30035 int val3 ;
30036 int ecode3 = 0 ;
30037 int val4 ;
30038 int ecode4 = 0 ;
30039 int val5 ;
30040 int ecode5 = 0 ;
30041 int val6 ;
30042 int ecode6 = 0 ;
30043 PyObject * obj0 = 0 ;
30044 PyObject * obj1 = 0 ;
30045 PyObject * obj2 = 0 ;
30046 PyObject * obj3 = 0 ;
30047 PyObject * obj4 = 0 ;
30048 PyObject * obj5 = 0 ;
30049 char * kwnames[] = {
30050 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30051 };
30052
30053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30055 if (!SWIG_IsOK(res1)) {
30056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30057 }
30058 arg1 = reinterpret_cast< wxWindow * >(argp1);
30059 ecode2 = SWIG_AsVal_int(obj1, &val2);
30060 if (!SWIG_IsOK(ecode2)) {
30061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30062 }
30063 arg2 = static_cast< int >(val2);
30064 ecode3 = SWIG_AsVal_int(obj2, &val3);
30065 if (!SWIG_IsOK(ecode3)) {
30066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30067 }
30068 arg3 = static_cast< int >(val3);
30069 ecode4 = SWIG_AsVal_int(obj3, &val4);
30070 if (!SWIG_IsOK(ecode4)) {
30071 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30072 }
30073 arg4 = static_cast< int >(val4);
30074 ecode5 = SWIG_AsVal_int(obj4, &val5);
30075 if (!SWIG_IsOK(ecode5)) {
30076 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30077 }
30078 arg5 = static_cast< int >(val5);
30079 if (obj5) {
30080 ecode6 = SWIG_AsVal_int(obj5, &val6);
30081 if (!SWIG_IsOK(ecode6)) {
30082 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30083 }
30084 arg6 = static_cast< int >(val6);
30085 }
30086 {
30087 PyThreadState* __tstate = wxPyBeginAllowThreads();
30088 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30089 wxPyEndAllowThreads(__tstate);
30090 if (PyErr_Occurred()) SWIG_fail;
30091 }
30092 resultobj = SWIG_Py_Void();
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30100 PyObject *resultobj = 0;
30101 wxWindow *arg1 = (wxWindow *) 0 ;
30102 wxRect *arg2 = 0 ;
30103 int arg3 = (int) wxSIZE_AUTO ;
30104 void *argp1 = 0 ;
30105 int res1 = 0 ;
30106 wxRect temp2 ;
30107 int val3 ;
30108 int ecode3 = 0 ;
30109 PyObject * obj0 = 0 ;
30110 PyObject * obj1 = 0 ;
30111 PyObject * obj2 = 0 ;
30112 char * kwnames[] = {
30113 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30114 };
30115
30116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30118 if (!SWIG_IsOK(res1)) {
30119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30120 }
30121 arg1 = reinterpret_cast< wxWindow * >(argp1);
30122 {
30123 arg2 = &temp2;
30124 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30125 }
30126 if (obj2) {
30127 ecode3 = SWIG_AsVal_int(obj2, &val3);
30128 if (!SWIG_IsOK(ecode3)) {
30129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30130 }
30131 arg3 = static_cast< int >(val3);
30132 }
30133 {
30134 PyThreadState* __tstate = wxPyBeginAllowThreads();
30135 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30136 wxPyEndAllowThreads(__tstate);
30137 if (PyErr_Occurred()) SWIG_fail;
30138 }
30139 resultobj = SWIG_Py_Void();
30140 return resultobj;
30141 fail:
30142 return NULL;
30143 }
30144
30145
30146 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30147 PyObject *resultobj = 0;
30148 wxWindow *arg1 = (wxWindow *) 0 ;
30149 int arg2 ;
30150 int arg3 ;
30151 void *argp1 = 0 ;
30152 int res1 = 0 ;
30153 int val2 ;
30154 int ecode2 = 0 ;
30155 int val3 ;
30156 int ecode3 = 0 ;
30157 PyObject * obj0 = 0 ;
30158 PyObject * obj1 = 0 ;
30159 PyObject * obj2 = 0 ;
30160 char * kwnames[] = {
30161 (char *) "self",(char *) "width",(char *) "height", NULL
30162 };
30163
30164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30166 if (!SWIG_IsOK(res1)) {
30167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30168 }
30169 arg1 = reinterpret_cast< wxWindow * >(argp1);
30170 ecode2 = SWIG_AsVal_int(obj1, &val2);
30171 if (!SWIG_IsOK(ecode2)) {
30172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30173 }
30174 arg2 = static_cast< int >(val2);
30175 ecode3 = SWIG_AsVal_int(obj2, &val3);
30176 if (!SWIG_IsOK(ecode3)) {
30177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30178 }
30179 arg3 = static_cast< int >(val3);
30180 {
30181 PyThreadState* __tstate = wxPyBeginAllowThreads();
30182 (arg1)->SetSize(arg2,arg3);
30183 wxPyEndAllowThreads(__tstate);
30184 if (PyErr_Occurred()) SWIG_fail;
30185 }
30186 resultobj = SWIG_Py_Void();
30187 return resultobj;
30188 fail:
30189 return NULL;
30190 }
30191
30192
30193 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30194 PyObject *resultobj = 0;
30195 wxWindow *arg1 = (wxWindow *) 0 ;
30196 wxPoint *arg2 = 0 ;
30197 int arg3 = (int) wxSIZE_USE_EXISTING ;
30198 void *argp1 = 0 ;
30199 int res1 = 0 ;
30200 wxPoint temp2 ;
30201 int val3 ;
30202 int ecode3 = 0 ;
30203 PyObject * obj0 = 0 ;
30204 PyObject * obj1 = 0 ;
30205 PyObject * obj2 = 0 ;
30206 char * kwnames[] = {
30207 (char *) "self",(char *) "pt",(char *) "flags", NULL
30208 };
30209
30210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30212 if (!SWIG_IsOK(res1)) {
30213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30214 }
30215 arg1 = reinterpret_cast< wxWindow * >(argp1);
30216 {
30217 arg2 = &temp2;
30218 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30219 }
30220 if (obj2) {
30221 ecode3 = SWIG_AsVal_int(obj2, &val3);
30222 if (!SWIG_IsOK(ecode3)) {
30223 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30224 }
30225 arg3 = static_cast< int >(val3);
30226 }
30227 {
30228 PyThreadState* __tstate = wxPyBeginAllowThreads();
30229 (arg1)->Move((wxPoint const &)*arg2,arg3);
30230 wxPyEndAllowThreads(__tstate);
30231 if (PyErr_Occurred()) SWIG_fail;
30232 }
30233 resultobj = SWIG_Py_Void();
30234 return resultobj;
30235 fail:
30236 return NULL;
30237 }
30238
30239
30240 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30241 PyObject *resultobj = 0;
30242 wxWindow *arg1 = (wxWindow *) 0 ;
30243 int arg2 ;
30244 int arg3 ;
30245 int arg4 = (int) wxSIZE_USE_EXISTING ;
30246 void *argp1 = 0 ;
30247 int res1 = 0 ;
30248 int val2 ;
30249 int ecode2 = 0 ;
30250 int val3 ;
30251 int ecode3 = 0 ;
30252 int val4 ;
30253 int ecode4 = 0 ;
30254 PyObject * obj0 = 0 ;
30255 PyObject * obj1 = 0 ;
30256 PyObject * obj2 = 0 ;
30257 PyObject * obj3 = 0 ;
30258 char * kwnames[] = {
30259 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30260 };
30261
30262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30264 if (!SWIG_IsOK(res1)) {
30265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30266 }
30267 arg1 = reinterpret_cast< wxWindow * >(argp1);
30268 ecode2 = SWIG_AsVal_int(obj1, &val2);
30269 if (!SWIG_IsOK(ecode2)) {
30270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30271 }
30272 arg2 = static_cast< int >(val2);
30273 ecode3 = SWIG_AsVal_int(obj2, &val3);
30274 if (!SWIG_IsOK(ecode3)) {
30275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30276 }
30277 arg3 = static_cast< int >(val3);
30278 if (obj3) {
30279 ecode4 = SWIG_AsVal_int(obj3, &val4);
30280 if (!SWIG_IsOK(ecode4)) {
30281 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30282 }
30283 arg4 = static_cast< int >(val4);
30284 }
30285 {
30286 PyThreadState* __tstate = wxPyBeginAllowThreads();
30287 (arg1)->Move(arg2,arg3,arg4);
30288 wxPyEndAllowThreads(__tstate);
30289 if (PyErr_Occurred()) SWIG_fail;
30290 }
30291 resultobj = SWIG_Py_Void();
30292 return resultobj;
30293 fail:
30294 return NULL;
30295 }
30296
30297
30298 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30299 PyObject *resultobj = 0;
30300 wxWindow *arg1 = (wxWindow *) 0 ;
30301 wxSize const &arg2_defvalue = wxDefaultSize ;
30302 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30303 void *argp1 = 0 ;
30304 int res1 = 0 ;
30305 wxSize temp2 ;
30306 PyObject * obj0 = 0 ;
30307 PyObject * obj1 = 0 ;
30308 char * kwnames[] = {
30309 (char *) "self",(char *) "size", NULL
30310 };
30311
30312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30314 if (!SWIG_IsOK(res1)) {
30315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30316 }
30317 arg1 = reinterpret_cast< wxWindow * >(argp1);
30318 if (obj1) {
30319 {
30320 arg2 = &temp2;
30321 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30322 }
30323 }
30324 {
30325 PyThreadState* __tstate = wxPyBeginAllowThreads();
30326 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30327 wxPyEndAllowThreads(__tstate);
30328 if (PyErr_Occurred()) SWIG_fail;
30329 }
30330 resultobj = SWIG_Py_Void();
30331 return resultobj;
30332 fail:
30333 return NULL;
30334 }
30335
30336
30337 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30338 PyObject *resultobj = 0;
30339 wxWindow *arg1 = (wxWindow *) 0 ;
30340 void *argp1 = 0 ;
30341 int res1 = 0 ;
30342 PyObject *swig_obj[1] ;
30343
30344 if (!args) SWIG_fail;
30345 swig_obj[0] = args;
30346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30347 if (!SWIG_IsOK(res1)) {
30348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30349 }
30350 arg1 = reinterpret_cast< wxWindow * >(argp1);
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 (arg1)->Raise();
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 resultobj = SWIG_Py_Void();
30358 return resultobj;
30359 fail:
30360 return NULL;
30361 }
30362
30363
30364 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30365 PyObject *resultobj = 0;
30366 wxWindow *arg1 = (wxWindow *) 0 ;
30367 void *argp1 = 0 ;
30368 int res1 = 0 ;
30369 PyObject *swig_obj[1] ;
30370
30371 if (!args) SWIG_fail;
30372 swig_obj[0] = args;
30373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30374 if (!SWIG_IsOK(res1)) {
30375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30376 }
30377 arg1 = reinterpret_cast< wxWindow * >(argp1);
30378 {
30379 PyThreadState* __tstate = wxPyBeginAllowThreads();
30380 (arg1)->Lower();
30381 wxPyEndAllowThreads(__tstate);
30382 if (PyErr_Occurred()) SWIG_fail;
30383 }
30384 resultobj = SWIG_Py_Void();
30385 return resultobj;
30386 fail:
30387 return NULL;
30388 }
30389
30390
30391 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30392 PyObject *resultobj = 0;
30393 wxWindow *arg1 = (wxWindow *) 0 ;
30394 wxSize *arg2 = 0 ;
30395 void *argp1 = 0 ;
30396 int res1 = 0 ;
30397 wxSize temp2 ;
30398 PyObject * obj0 = 0 ;
30399 PyObject * obj1 = 0 ;
30400 char * kwnames[] = {
30401 (char *) "self",(char *) "size", NULL
30402 };
30403
30404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30406 if (!SWIG_IsOK(res1)) {
30407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30408 }
30409 arg1 = reinterpret_cast< wxWindow * >(argp1);
30410 {
30411 arg2 = &temp2;
30412 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30413 }
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 (arg1)->SetClientSize((wxSize const &)*arg2);
30417 wxPyEndAllowThreads(__tstate);
30418 if (PyErr_Occurred()) SWIG_fail;
30419 }
30420 resultobj = SWIG_Py_Void();
30421 return resultobj;
30422 fail:
30423 return NULL;
30424 }
30425
30426
30427 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30428 PyObject *resultobj = 0;
30429 wxWindow *arg1 = (wxWindow *) 0 ;
30430 int arg2 ;
30431 int arg3 ;
30432 void *argp1 = 0 ;
30433 int res1 = 0 ;
30434 int val2 ;
30435 int ecode2 = 0 ;
30436 int val3 ;
30437 int ecode3 = 0 ;
30438 PyObject * obj0 = 0 ;
30439 PyObject * obj1 = 0 ;
30440 PyObject * obj2 = 0 ;
30441 char * kwnames[] = {
30442 (char *) "self",(char *) "width",(char *) "height", NULL
30443 };
30444
30445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30447 if (!SWIG_IsOK(res1)) {
30448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30449 }
30450 arg1 = reinterpret_cast< wxWindow * >(argp1);
30451 ecode2 = SWIG_AsVal_int(obj1, &val2);
30452 if (!SWIG_IsOK(ecode2)) {
30453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30454 }
30455 arg2 = static_cast< int >(val2);
30456 ecode3 = SWIG_AsVal_int(obj2, &val3);
30457 if (!SWIG_IsOK(ecode3)) {
30458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30459 }
30460 arg3 = static_cast< int >(val3);
30461 {
30462 PyThreadState* __tstate = wxPyBeginAllowThreads();
30463 (arg1)->SetClientSize(arg2,arg3);
30464 wxPyEndAllowThreads(__tstate);
30465 if (PyErr_Occurred()) SWIG_fail;
30466 }
30467 resultobj = SWIG_Py_Void();
30468 return resultobj;
30469 fail:
30470 return NULL;
30471 }
30472
30473
30474 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30475 PyObject *resultobj = 0;
30476 wxWindow *arg1 = (wxWindow *) 0 ;
30477 wxRect *arg2 = 0 ;
30478 void *argp1 = 0 ;
30479 int res1 = 0 ;
30480 wxRect temp2 ;
30481 PyObject * obj0 = 0 ;
30482 PyObject * obj1 = 0 ;
30483 char * kwnames[] = {
30484 (char *) "self",(char *) "rect", NULL
30485 };
30486
30487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30489 if (!SWIG_IsOK(res1)) {
30490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30491 }
30492 arg1 = reinterpret_cast< wxWindow * >(argp1);
30493 {
30494 arg2 = &temp2;
30495 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30496 }
30497 {
30498 PyThreadState* __tstate = wxPyBeginAllowThreads();
30499 (arg1)->SetClientSize((wxRect const &)*arg2);
30500 wxPyEndAllowThreads(__tstate);
30501 if (PyErr_Occurred()) SWIG_fail;
30502 }
30503 resultobj = SWIG_Py_Void();
30504 return resultobj;
30505 fail:
30506 return NULL;
30507 }
30508
30509
30510 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30511 PyObject *resultobj = 0;
30512 wxWindow *arg1 = (wxWindow *) 0 ;
30513 wxPoint result;
30514 void *argp1 = 0 ;
30515 int res1 = 0 ;
30516 PyObject *swig_obj[1] ;
30517
30518 if (!args) SWIG_fail;
30519 swig_obj[0] = args;
30520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30521 if (!SWIG_IsOK(res1)) {
30522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow *""'");
30523 }
30524 arg1 = reinterpret_cast< wxWindow * >(argp1);
30525 {
30526 PyThreadState* __tstate = wxPyBeginAllowThreads();
30527 result = (arg1)->GetPosition();
30528 wxPyEndAllowThreads(__tstate);
30529 if (PyErr_Occurred()) SWIG_fail;
30530 }
30531 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30532 return resultobj;
30533 fail:
30534 return NULL;
30535 }
30536
30537
30538 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30539 PyObject *resultobj = 0;
30540 wxWindow *arg1 = (wxWindow *) 0 ;
30541 int *arg2 = (int *) 0 ;
30542 int *arg3 = (int *) 0 ;
30543 void *argp1 = 0 ;
30544 int res1 = 0 ;
30545 int temp2 ;
30546 int res2 = SWIG_TMPOBJ ;
30547 int temp3 ;
30548 int res3 = SWIG_TMPOBJ ;
30549 PyObject *swig_obj[1] ;
30550
30551 arg2 = &temp2;
30552 arg3 = &temp3;
30553 if (!args) SWIG_fail;
30554 swig_obj[0] = args;
30555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30556 if (!SWIG_IsOK(res1)) {
30557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow *""'");
30558 }
30559 arg1 = reinterpret_cast< wxWindow * >(argp1);
30560 {
30561 PyThreadState* __tstate = wxPyBeginAllowThreads();
30562 (arg1)->GetPosition(arg2,arg3);
30563 wxPyEndAllowThreads(__tstate);
30564 if (PyErr_Occurred()) SWIG_fail;
30565 }
30566 resultobj = SWIG_Py_Void();
30567 if (SWIG_IsTmpObj(res2)) {
30568 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30569 } else {
30570 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30571 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30572 }
30573 if (SWIG_IsTmpObj(res3)) {
30574 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30575 } else {
30576 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30577 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30578 }
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30586 PyObject *resultobj = 0;
30587 wxWindow *arg1 = (wxWindow *) 0 ;
30588 wxSize result;
30589 void *argp1 = 0 ;
30590 int res1 = 0 ;
30591 PyObject *swig_obj[1] ;
30592
30593 if (!args) SWIG_fail;
30594 swig_obj[0] = args;
30595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30596 if (!SWIG_IsOK(res1)) {
30597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30598 }
30599 arg1 = reinterpret_cast< wxWindow * >(argp1);
30600 {
30601 PyThreadState* __tstate = wxPyBeginAllowThreads();
30602 result = ((wxWindow const *)arg1)->GetSize();
30603 wxPyEndAllowThreads(__tstate);
30604 if (PyErr_Occurred()) SWIG_fail;
30605 }
30606 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30607 return resultobj;
30608 fail:
30609 return NULL;
30610 }
30611
30612
30613 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30614 PyObject *resultobj = 0;
30615 wxWindow *arg1 = (wxWindow *) 0 ;
30616 int *arg2 = (int *) 0 ;
30617 int *arg3 = (int *) 0 ;
30618 void *argp1 = 0 ;
30619 int res1 = 0 ;
30620 int temp2 ;
30621 int res2 = SWIG_TMPOBJ ;
30622 int temp3 ;
30623 int res3 = SWIG_TMPOBJ ;
30624 PyObject *swig_obj[1] ;
30625
30626 arg2 = &temp2;
30627 arg3 = &temp3;
30628 if (!args) SWIG_fail;
30629 swig_obj[0] = args;
30630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30631 if (!SWIG_IsOK(res1)) {
30632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30633 }
30634 arg1 = reinterpret_cast< wxWindow * >(argp1);
30635 {
30636 PyThreadState* __tstate = wxPyBeginAllowThreads();
30637 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30638 wxPyEndAllowThreads(__tstate);
30639 if (PyErr_Occurred()) SWIG_fail;
30640 }
30641 resultobj = SWIG_Py_Void();
30642 if (SWIG_IsTmpObj(res2)) {
30643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30644 } else {
30645 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30647 }
30648 if (SWIG_IsTmpObj(res3)) {
30649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30650 } else {
30651 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30653 }
30654 return resultobj;
30655 fail:
30656 return NULL;
30657 }
30658
30659
30660 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30661 PyObject *resultobj = 0;
30662 wxWindow *arg1 = (wxWindow *) 0 ;
30663 wxRect result;
30664 void *argp1 = 0 ;
30665 int res1 = 0 ;
30666 PyObject *swig_obj[1] ;
30667
30668 if (!args) SWIG_fail;
30669 swig_obj[0] = args;
30670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30671 if (!SWIG_IsOK(res1)) {
30672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30673 }
30674 arg1 = reinterpret_cast< wxWindow * >(argp1);
30675 {
30676 PyThreadState* __tstate = wxPyBeginAllowThreads();
30677 result = ((wxWindow const *)arg1)->GetRect();
30678 wxPyEndAllowThreads(__tstate);
30679 if (PyErr_Occurred()) SWIG_fail;
30680 }
30681 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30689 PyObject *resultobj = 0;
30690 wxWindow *arg1 = (wxWindow *) 0 ;
30691 wxSize result;
30692 void *argp1 = 0 ;
30693 int res1 = 0 ;
30694 PyObject *swig_obj[1] ;
30695
30696 if (!args) SWIG_fail;
30697 swig_obj[0] = args;
30698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30699 if (!SWIG_IsOK(res1)) {
30700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30701 }
30702 arg1 = reinterpret_cast< wxWindow * >(argp1);
30703 {
30704 PyThreadState* __tstate = wxPyBeginAllowThreads();
30705 result = ((wxWindow const *)arg1)->GetClientSize();
30706 wxPyEndAllowThreads(__tstate);
30707 if (PyErr_Occurred()) SWIG_fail;
30708 }
30709 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30717 PyObject *resultobj = 0;
30718 wxWindow *arg1 = (wxWindow *) 0 ;
30719 int *arg2 = (int *) 0 ;
30720 int *arg3 = (int *) 0 ;
30721 void *argp1 = 0 ;
30722 int res1 = 0 ;
30723 int temp2 ;
30724 int res2 = SWIG_TMPOBJ ;
30725 int temp3 ;
30726 int res3 = SWIG_TMPOBJ ;
30727 PyObject *swig_obj[1] ;
30728
30729 arg2 = &temp2;
30730 arg3 = &temp3;
30731 if (!args) SWIG_fail;
30732 swig_obj[0] = args;
30733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30734 if (!SWIG_IsOK(res1)) {
30735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30736 }
30737 arg1 = reinterpret_cast< wxWindow * >(argp1);
30738 {
30739 PyThreadState* __tstate = wxPyBeginAllowThreads();
30740 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30741 wxPyEndAllowThreads(__tstate);
30742 if (PyErr_Occurred()) SWIG_fail;
30743 }
30744 resultobj = SWIG_Py_Void();
30745 if (SWIG_IsTmpObj(res2)) {
30746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30747 } else {
30748 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30750 }
30751 if (SWIG_IsTmpObj(res3)) {
30752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30753 } else {
30754 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30756 }
30757 return resultobj;
30758 fail:
30759 return NULL;
30760 }
30761
30762
30763 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30764 PyObject *resultobj = 0;
30765 wxWindow *arg1 = (wxWindow *) 0 ;
30766 wxPoint result;
30767 void *argp1 = 0 ;
30768 int res1 = 0 ;
30769 PyObject *swig_obj[1] ;
30770
30771 if (!args) SWIG_fail;
30772 swig_obj[0] = args;
30773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30774 if (!SWIG_IsOK(res1)) {
30775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30776 }
30777 arg1 = reinterpret_cast< wxWindow * >(argp1);
30778 {
30779 PyThreadState* __tstate = wxPyBeginAllowThreads();
30780 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30781 wxPyEndAllowThreads(__tstate);
30782 if (PyErr_Occurred()) SWIG_fail;
30783 }
30784 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30785 return resultobj;
30786 fail:
30787 return NULL;
30788 }
30789
30790
30791 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30792 PyObject *resultobj = 0;
30793 wxWindow *arg1 = (wxWindow *) 0 ;
30794 wxRect result;
30795 void *argp1 = 0 ;
30796 int res1 = 0 ;
30797 PyObject *swig_obj[1] ;
30798
30799 if (!args) SWIG_fail;
30800 swig_obj[0] = args;
30801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30802 if (!SWIG_IsOK(res1)) {
30803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30804 }
30805 arg1 = reinterpret_cast< wxWindow * >(argp1);
30806 {
30807 PyThreadState* __tstate = wxPyBeginAllowThreads();
30808 result = ((wxWindow const *)arg1)->GetClientRect();
30809 wxPyEndAllowThreads(__tstate);
30810 if (PyErr_Occurred()) SWIG_fail;
30811 }
30812 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30820 PyObject *resultobj = 0;
30821 wxWindow *arg1 = (wxWindow *) 0 ;
30822 wxSize result;
30823 void *argp1 = 0 ;
30824 int res1 = 0 ;
30825 PyObject *swig_obj[1] ;
30826
30827 if (!args) SWIG_fail;
30828 swig_obj[0] = args;
30829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30830 if (!SWIG_IsOK(res1)) {
30831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30832 }
30833 arg1 = reinterpret_cast< wxWindow * >(argp1);
30834 {
30835 PyThreadState* __tstate = wxPyBeginAllowThreads();
30836 result = ((wxWindow const *)arg1)->GetBestSize();
30837 wxPyEndAllowThreads(__tstate);
30838 if (PyErr_Occurred()) SWIG_fail;
30839 }
30840 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30841 return resultobj;
30842 fail:
30843 return NULL;
30844 }
30845
30846
30847 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30848 PyObject *resultobj = 0;
30849 wxWindow *arg1 = (wxWindow *) 0 ;
30850 int *arg2 = (int *) 0 ;
30851 int *arg3 = (int *) 0 ;
30852 void *argp1 = 0 ;
30853 int res1 = 0 ;
30854 int temp2 ;
30855 int res2 = SWIG_TMPOBJ ;
30856 int temp3 ;
30857 int res3 = SWIG_TMPOBJ ;
30858 PyObject *swig_obj[1] ;
30859
30860 arg2 = &temp2;
30861 arg3 = &temp3;
30862 if (!args) SWIG_fail;
30863 swig_obj[0] = args;
30864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30865 if (!SWIG_IsOK(res1)) {
30866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30867 }
30868 arg1 = reinterpret_cast< wxWindow * >(argp1);
30869 {
30870 PyThreadState* __tstate = wxPyBeginAllowThreads();
30871 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
30872 wxPyEndAllowThreads(__tstate);
30873 if (PyErr_Occurred()) SWIG_fail;
30874 }
30875 resultobj = SWIG_Py_Void();
30876 if (SWIG_IsTmpObj(res2)) {
30877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30878 } else {
30879 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30881 }
30882 if (SWIG_IsTmpObj(res3)) {
30883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30884 } else {
30885 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30887 }
30888 return resultobj;
30889 fail:
30890 return NULL;
30891 }
30892
30893
30894 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30895 PyObject *resultobj = 0;
30896 wxWindow *arg1 = (wxWindow *) 0 ;
30897 void *argp1 = 0 ;
30898 int res1 = 0 ;
30899 PyObject *swig_obj[1] ;
30900
30901 if (!args) SWIG_fail;
30902 swig_obj[0] = args;
30903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30904 if (!SWIG_IsOK(res1)) {
30905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30906 }
30907 arg1 = reinterpret_cast< wxWindow * >(argp1);
30908 {
30909 PyThreadState* __tstate = wxPyBeginAllowThreads();
30910 (arg1)->InvalidateBestSize();
30911 wxPyEndAllowThreads(__tstate);
30912 if (PyErr_Occurred()) SWIG_fail;
30913 }
30914 resultobj = SWIG_Py_Void();
30915 return resultobj;
30916 fail:
30917 return NULL;
30918 }
30919
30920
30921 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30922 PyObject *resultobj = 0;
30923 wxWindow *arg1 = (wxWindow *) 0 ;
30924 wxSize *arg2 = 0 ;
30925 void *argp1 = 0 ;
30926 int res1 = 0 ;
30927 wxSize temp2 ;
30928 PyObject * obj0 = 0 ;
30929 PyObject * obj1 = 0 ;
30930 char * kwnames[] = {
30931 (char *) "self",(char *) "size", NULL
30932 };
30933
30934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
30935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30936 if (!SWIG_IsOK(res1)) {
30937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30938 }
30939 arg1 = reinterpret_cast< wxWindow * >(argp1);
30940 {
30941 arg2 = &temp2;
30942 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30943 }
30944 {
30945 PyThreadState* __tstate = wxPyBeginAllowThreads();
30946 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
30947 wxPyEndAllowThreads(__tstate);
30948 if (PyErr_Occurred()) SWIG_fail;
30949 }
30950 resultobj = SWIG_Py_Void();
30951 return resultobj;
30952 fail:
30953 return NULL;
30954 }
30955
30956
30957 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30958 PyObject *resultobj = 0;
30959 wxWindow *arg1 = (wxWindow *) 0 ;
30960 wxSize result;
30961 void *argp1 = 0 ;
30962 int res1 = 0 ;
30963 PyObject *swig_obj[1] ;
30964
30965 if (!args) SWIG_fail;
30966 swig_obj[0] = args;
30967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30968 if (!SWIG_IsOK(res1)) {
30969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30970 }
30971 arg1 = reinterpret_cast< wxWindow * >(argp1);
30972 {
30973 PyThreadState* __tstate = wxPyBeginAllowThreads();
30974 result = ((wxWindow const *)arg1)->GetBestFittingSize();
30975 wxPyEndAllowThreads(__tstate);
30976 if (PyErr_Occurred()) SWIG_fail;
30977 }
30978 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30979 return resultobj;
30980 fail:
30981 return NULL;
30982 }
30983
30984
30985 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30986 PyObject *resultobj = 0;
30987 wxWindow *arg1 = (wxWindow *) 0 ;
30988 wxSize result;
30989 void *argp1 = 0 ;
30990 int res1 = 0 ;
30991 PyObject *swig_obj[1] ;
30992
30993 if (!args) SWIG_fail;
30994 swig_obj[0] = args;
30995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30996 if (!SWIG_IsOK(res1)) {
30997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30998 }
30999 arg1 = reinterpret_cast< wxWindow * >(argp1);
31000 {
31001 PyThreadState* __tstate = wxPyBeginAllowThreads();
31002 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31003 wxPyEndAllowThreads(__tstate);
31004 if (PyErr_Occurred()) SWIG_fail;
31005 }
31006 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31007 return resultobj;
31008 fail:
31009 return NULL;
31010 }
31011
31012
31013 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31014 PyObject *resultobj = 0;
31015 wxWindow *arg1 = (wxWindow *) 0 ;
31016 int arg2 = (int) wxBOTH ;
31017 void *argp1 = 0 ;
31018 int res1 = 0 ;
31019 int val2 ;
31020 int ecode2 = 0 ;
31021 PyObject * obj0 = 0 ;
31022 PyObject * obj1 = 0 ;
31023 char * kwnames[] = {
31024 (char *) "self",(char *) "direction", NULL
31025 };
31026
31027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31029 if (!SWIG_IsOK(res1)) {
31030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31031 }
31032 arg1 = reinterpret_cast< wxWindow * >(argp1);
31033 if (obj1) {
31034 ecode2 = SWIG_AsVal_int(obj1, &val2);
31035 if (!SWIG_IsOK(ecode2)) {
31036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31037 }
31038 arg2 = static_cast< int >(val2);
31039 }
31040 {
31041 PyThreadState* __tstate = wxPyBeginAllowThreads();
31042 (arg1)->Center(arg2);
31043 wxPyEndAllowThreads(__tstate);
31044 if (PyErr_Occurred()) SWIG_fail;
31045 }
31046 resultobj = SWIG_Py_Void();
31047 return resultobj;
31048 fail:
31049 return NULL;
31050 }
31051
31052
31053 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31054 PyObject *resultobj = 0;
31055 wxWindow *arg1 = (wxWindow *) 0 ;
31056 int arg2 = (int) wxBOTH ;
31057 void *argp1 = 0 ;
31058 int res1 = 0 ;
31059 int val2 ;
31060 int ecode2 = 0 ;
31061 PyObject * obj0 = 0 ;
31062 PyObject * obj1 = 0 ;
31063 char * kwnames[] = {
31064 (char *) "self",(char *) "dir", NULL
31065 };
31066
31067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31069 if (!SWIG_IsOK(res1)) {
31070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31071 }
31072 arg1 = reinterpret_cast< wxWindow * >(argp1);
31073 if (obj1) {
31074 ecode2 = SWIG_AsVal_int(obj1, &val2);
31075 if (!SWIG_IsOK(ecode2)) {
31076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31077 }
31078 arg2 = static_cast< int >(val2);
31079 }
31080 {
31081 PyThreadState* __tstate = wxPyBeginAllowThreads();
31082 (arg1)->CenterOnParent(arg2);
31083 wxPyEndAllowThreads(__tstate);
31084 if (PyErr_Occurred()) SWIG_fail;
31085 }
31086 resultobj = SWIG_Py_Void();
31087 return resultobj;
31088 fail:
31089 return NULL;
31090 }
31091
31092
31093 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31094 PyObject *resultobj = 0;
31095 wxWindow *arg1 = (wxWindow *) 0 ;
31096 void *argp1 = 0 ;
31097 int res1 = 0 ;
31098 PyObject *swig_obj[1] ;
31099
31100 if (!args) SWIG_fail;
31101 swig_obj[0] = args;
31102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31103 if (!SWIG_IsOK(res1)) {
31104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31105 }
31106 arg1 = reinterpret_cast< wxWindow * >(argp1);
31107 {
31108 PyThreadState* __tstate = wxPyBeginAllowThreads();
31109 (arg1)->Fit();
31110 wxPyEndAllowThreads(__tstate);
31111 if (PyErr_Occurred()) SWIG_fail;
31112 }
31113 resultobj = SWIG_Py_Void();
31114 return resultobj;
31115 fail:
31116 return NULL;
31117 }
31118
31119
31120 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31121 PyObject *resultobj = 0;
31122 wxWindow *arg1 = (wxWindow *) 0 ;
31123 void *argp1 = 0 ;
31124 int res1 = 0 ;
31125 PyObject *swig_obj[1] ;
31126
31127 if (!args) SWIG_fail;
31128 swig_obj[0] = args;
31129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31130 if (!SWIG_IsOK(res1)) {
31131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31132 }
31133 arg1 = reinterpret_cast< wxWindow * >(argp1);
31134 {
31135 PyThreadState* __tstate = wxPyBeginAllowThreads();
31136 (arg1)->FitInside();
31137 wxPyEndAllowThreads(__tstate);
31138 if (PyErr_Occurred()) SWIG_fail;
31139 }
31140 resultobj = SWIG_Py_Void();
31141 return resultobj;
31142 fail:
31143 return NULL;
31144 }
31145
31146
31147 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31148 PyObject *resultobj = 0;
31149 wxWindow *arg1 = (wxWindow *) 0 ;
31150 int arg2 ;
31151 int arg3 ;
31152 int arg4 = (int) -1 ;
31153 int arg5 = (int) -1 ;
31154 int arg6 = (int) -1 ;
31155 int arg7 = (int) -1 ;
31156 void *argp1 = 0 ;
31157 int res1 = 0 ;
31158 int val2 ;
31159 int ecode2 = 0 ;
31160 int val3 ;
31161 int ecode3 = 0 ;
31162 int val4 ;
31163 int ecode4 = 0 ;
31164 int val5 ;
31165 int ecode5 = 0 ;
31166 int val6 ;
31167 int ecode6 = 0 ;
31168 int val7 ;
31169 int ecode7 = 0 ;
31170 PyObject * obj0 = 0 ;
31171 PyObject * obj1 = 0 ;
31172 PyObject * obj2 = 0 ;
31173 PyObject * obj3 = 0 ;
31174 PyObject * obj4 = 0 ;
31175 PyObject * obj5 = 0 ;
31176 PyObject * obj6 = 0 ;
31177 char * kwnames[] = {
31178 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31179 };
31180
31181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31183 if (!SWIG_IsOK(res1)) {
31184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31185 }
31186 arg1 = reinterpret_cast< wxWindow * >(argp1);
31187 ecode2 = SWIG_AsVal_int(obj1, &val2);
31188 if (!SWIG_IsOK(ecode2)) {
31189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31190 }
31191 arg2 = static_cast< int >(val2);
31192 ecode3 = SWIG_AsVal_int(obj2, &val3);
31193 if (!SWIG_IsOK(ecode3)) {
31194 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31195 }
31196 arg3 = static_cast< int >(val3);
31197 if (obj3) {
31198 ecode4 = SWIG_AsVal_int(obj3, &val4);
31199 if (!SWIG_IsOK(ecode4)) {
31200 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31201 }
31202 arg4 = static_cast< int >(val4);
31203 }
31204 if (obj4) {
31205 ecode5 = SWIG_AsVal_int(obj4, &val5);
31206 if (!SWIG_IsOK(ecode5)) {
31207 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31208 }
31209 arg5 = static_cast< int >(val5);
31210 }
31211 if (obj5) {
31212 ecode6 = SWIG_AsVal_int(obj5, &val6);
31213 if (!SWIG_IsOK(ecode6)) {
31214 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31215 }
31216 arg6 = static_cast< int >(val6);
31217 }
31218 if (obj6) {
31219 ecode7 = SWIG_AsVal_int(obj6, &val7);
31220 if (!SWIG_IsOK(ecode7)) {
31221 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31222 }
31223 arg7 = static_cast< int >(val7);
31224 }
31225 {
31226 PyThreadState* __tstate = wxPyBeginAllowThreads();
31227 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31228 wxPyEndAllowThreads(__tstate);
31229 if (PyErr_Occurred()) SWIG_fail;
31230 }
31231 resultobj = SWIG_Py_Void();
31232 return resultobj;
31233 fail:
31234 return NULL;
31235 }
31236
31237
31238 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31239 PyObject *resultobj = 0;
31240 wxWindow *arg1 = (wxWindow *) 0 ;
31241 wxSize *arg2 = 0 ;
31242 wxSize const &arg3_defvalue = wxDefaultSize ;
31243 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31244 wxSize const &arg4_defvalue = wxDefaultSize ;
31245 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31246 void *argp1 = 0 ;
31247 int res1 = 0 ;
31248 wxSize temp2 ;
31249 wxSize temp3 ;
31250 wxSize temp4 ;
31251 PyObject * obj0 = 0 ;
31252 PyObject * obj1 = 0 ;
31253 PyObject * obj2 = 0 ;
31254 PyObject * obj3 = 0 ;
31255 char * kwnames[] = {
31256 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31257 };
31258
31259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31261 if (!SWIG_IsOK(res1)) {
31262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31263 }
31264 arg1 = reinterpret_cast< wxWindow * >(argp1);
31265 {
31266 arg2 = &temp2;
31267 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31268 }
31269 if (obj2) {
31270 {
31271 arg3 = &temp3;
31272 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31273 }
31274 }
31275 if (obj3) {
31276 {
31277 arg4 = &temp4;
31278 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31279 }
31280 }
31281 {
31282 PyThreadState* __tstate = wxPyBeginAllowThreads();
31283 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31284 wxPyEndAllowThreads(__tstate);
31285 if (PyErr_Occurred()) SWIG_fail;
31286 }
31287 resultobj = SWIG_Py_Void();
31288 return resultobj;
31289 fail:
31290 return NULL;
31291 }
31292
31293
31294 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31295 PyObject *resultobj = 0;
31296 wxWindow *arg1 = (wxWindow *) 0 ;
31297 int arg2 ;
31298 int arg3 ;
31299 int arg4 = (int) -1 ;
31300 int arg5 = (int) -1 ;
31301 void *argp1 = 0 ;
31302 int res1 = 0 ;
31303 int val2 ;
31304 int ecode2 = 0 ;
31305 int val3 ;
31306 int ecode3 = 0 ;
31307 int val4 ;
31308 int ecode4 = 0 ;
31309 int val5 ;
31310 int ecode5 = 0 ;
31311 PyObject * obj0 = 0 ;
31312 PyObject * obj1 = 0 ;
31313 PyObject * obj2 = 0 ;
31314 PyObject * obj3 = 0 ;
31315 PyObject * obj4 = 0 ;
31316 char * kwnames[] = {
31317 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31318 };
31319
31320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31322 if (!SWIG_IsOK(res1)) {
31323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31324 }
31325 arg1 = reinterpret_cast< wxWindow * >(argp1);
31326 ecode2 = SWIG_AsVal_int(obj1, &val2);
31327 if (!SWIG_IsOK(ecode2)) {
31328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31329 }
31330 arg2 = static_cast< int >(val2);
31331 ecode3 = SWIG_AsVal_int(obj2, &val3);
31332 if (!SWIG_IsOK(ecode3)) {
31333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31334 }
31335 arg3 = static_cast< int >(val3);
31336 if (obj3) {
31337 ecode4 = SWIG_AsVal_int(obj3, &val4);
31338 if (!SWIG_IsOK(ecode4)) {
31339 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31340 }
31341 arg4 = static_cast< int >(val4);
31342 }
31343 if (obj4) {
31344 ecode5 = SWIG_AsVal_int(obj4, &val5);
31345 if (!SWIG_IsOK(ecode5)) {
31346 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31347 }
31348 arg5 = static_cast< int >(val5);
31349 }
31350 {
31351 PyThreadState* __tstate = wxPyBeginAllowThreads();
31352 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31353 wxPyEndAllowThreads(__tstate);
31354 if (PyErr_Occurred()) SWIG_fail;
31355 }
31356 resultobj = SWIG_Py_Void();
31357 return resultobj;
31358 fail:
31359 return NULL;
31360 }
31361
31362
31363 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31364 PyObject *resultobj = 0;
31365 wxWindow *arg1 = (wxWindow *) 0 ;
31366 wxSize *arg2 = 0 ;
31367 wxSize const &arg3_defvalue = wxDefaultSize ;
31368 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31369 void *argp1 = 0 ;
31370 int res1 = 0 ;
31371 wxSize temp2 ;
31372 wxSize temp3 ;
31373 PyObject * obj0 = 0 ;
31374 PyObject * obj1 = 0 ;
31375 PyObject * obj2 = 0 ;
31376 char * kwnames[] = {
31377 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31378 };
31379
31380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) 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_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31384 }
31385 arg1 = reinterpret_cast< wxWindow * >(argp1);
31386 {
31387 arg2 = &temp2;
31388 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31389 }
31390 if (obj2) {
31391 {
31392 arg3 = &temp3;
31393 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31394 }
31395 }
31396 {
31397 PyThreadState* __tstate = wxPyBeginAllowThreads();
31398 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31399 wxPyEndAllowThreads(__tstate);
31400 if (PyErr_Occurred()) SWIG_fail;
31401 }
31402 resultobj = SWIG_Py_Void();
31403 return resultobj;
31404 fail:
31405 return NULL;
31406 }
31407
31408
31409 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31410 PyObject *resultobj = 0;
31411 wxWindow *arg1 = (wxWindow *) 0 ;
31412 wxSize result;
31413 void *argp1 = 0 ;
31414 int res1 = 0 ;
31415 PyObject *swig_obj[1] ;
31416
31417 if (!args) SWIG_fail;
31418 swig_obj[0] = args;
31419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31420 if (!SWIG_IsOK(res1)) {
31421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31422 }
31423 arg1 = reinterpret_cast< wxWindow * >(argp1);
31424 {
31425 PyThreadState* __tstate = wxPyBeginAllowThreads();
31426 result = ((wxWindow const *)arg1)->GetMaxSize();
31427 wxPyEndAllowThreads(__tstate);
31428 if (PyErr_Occurred()) SWIG_fail;
31429 }
31430 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31431 return resultobj;
31432 fail:
31433 return NULL;
31434 }
31435
31436
31437 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31438 PyObject *resultobj = 0;
31439 wxWindow *arg1 = (wxWindow *) 0 ;
31440 wxSize result;
31441 void *argp1 = 0 ;
31442 int res1 = 0 ;
31443 PyObject *swig_obj[1] ;
31444
31445 if (!args) SWIG_fail;
31446 swig_obj[0] = args;
31447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31448 if (!SWIG_IsOK(res1)) {
31449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31450 }
31451 arg1 = reinterpret_cast< wxWindow * >(argp1);
31452 {
31453 PyThreadState* __tstate = wxPyBeginAllowThreads();
31454 result = ((wxWindow const *)arg1)->GetMinSize();
31455 wxPyEndAllowThreads(__tstate);
31456 if (PyErr_Occurred()) SWIG_fail;
31457 }
31458 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31459 return resultobj;
31460 fail:
31461 return NULL;
31462 }
31463
31464
31465 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31466 PyObject *resultobj = 0;
31467 wxWindow *arg1 = (wxWindow *) 0 ;
31468 wxSize *arg2 = 0 ;
31469 void *argp1 = 0 ;
31470 int res1 = 0 ;
31471 wxSize temp2 ;
31472 PyObject * obj0 = 0 ;
31473 PyObject * obj1 = 0 ;
31474 char * kwnames[] = {
31475 (char *) "self",(char *) "minSize", NULL
31476 };
31477
31478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31480 if (!SWIG_IsOK(res1)) {
31481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31482 }
31483 arg1 = reinterpret_cast< wxWindow * >(argp1);
31484 {
31485 arg2 = &temp2;
31486 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31487 }
31488 {
31489 PyThreadState* __tstate = wxPyBeginAllowThreads();
31490 (arg1)->SetMinSize((wxSize const &)*arg2);
31491 wxPyEndAllowThreads(__tstate);
31492 if (PyErr_Occurred()) SWIG_fail;
31493 }
31494 resultobj = SWIG_Py_Void();
31495 return resultobj;
31496 fail:
31497 return NULL;
31498 }
31499
31500
31501 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31502 PyObject *resultobj = 0;
31503 wxWindow *arg1 = (wxWindow *) 0 ;
31504 wxSize *arg2 = 0 ;
31505 void *argp1 = 0 ;
31506 int res1 = 0 ;
31507 wxSize temp2 ;
31508 PyObject * obj0 = 0 ;
31509 PyObject * obj1 = 0 ;
31510 char * kwnames[] = {
31511 (char *) "self",(char *) "maxSize", NULL
31512 };
31513
31514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31516 if (!SWIG_IsOK(res1)) {
31517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31518 }
31519 arg1 = reinterpret_cast< wxWindow * >(argp1);
31520 {
31521 arg2 = &temp2;
31522 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31523 }
31524 {
31525 PyThreadState* __tstate = wxPyBeginAllowThreads();
31526 (arg1)->SetMaxSize((wxSize const &)*arg2);
31527 wxPyEndAllowThreads(__tstate);
31528 if (PyErr_Occurred()) SWIG_fail;
31529 }
31530 resultobj = SWIG_Py_Void();
31531 return resultobj;
31532 fail:
31533 return NULL;
31534 }
31535
31536
31537 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31538 PyObject *resultobj = 0;
31539 wxWindow *arg1 = (wxWindow *) 0 ;
31540 int result;
31541 void *argp1 = 0 ;
31542 int res1 = 0 ;
31543 PyObject *swig_obj[1] ;
31544
31545 if (!args) SWIG_fail;
31546 swig_obj[0] = args;
31547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31548 if (!SWIG_IsOK(res1)) {
31549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31550 }
31551 arg1 = reinterpret_cast< wxWindow * >(argp1);
31552 {
31553 PyThreadState* __tstate = wxPyBeginAllowThreads();
31554 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31555 wxPyEndAllowThreads(__tstate);
31556 if (PyErr_Occurred()) SWIG_fail;
31557 }
31558 resultobj = SWIG_From_int(static_cast< int >(result));
31559 return resultobj;
31560 fail:
31561 return NULL;
31562 }
31563
31564
31565 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31566 PyObject *resultobj = 0;
31567 wxWindow *arg1 = (wxWindow *) 0 ;
31568 int result;
31569 void *argp1 = 0 ;
31570 int res1 = 0 ;
31571 PyObject *swig_obj[1] ;
31572
31573 if (!args) SWIG_fail;
31574 swig_obj[0] = args;
31575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31576 if (!SWIG_IsOK(res1)) {
31577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31578 }
31579 arg1 = reinterpret_cast< wxWindow * >(argp1);
31580 {
31581 PyThreadState* __tstate = wxPyBeginAllowThreads();
31582 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31583 wxPyEndAllowThreads(__tstate);
31584 if (PyErr_Occurred()) SWIG_fail;
31585 }
31586 resultobj = SWIG_From_int(static_cast< int >(result));
31587 return resultobj;
31588 fail:
31589 return NULL;
31590 }
31591
31592
31593 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31594 PyObject *resultobj = 0;
31595 wxWindow *arg1 = (wxWindow *) 0 ;
31596 int result;
31597 void *argp1 = 0 ;
31598 int res1 = 0 ;
31599 PyObject *swig_obj[1] ;
31600
31601 if (!args) SWIG_fail;
31602 swig_obj[0] = args;
31603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31604 if (!SWIG_IsOK(res1)) {
31605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31606 }
31607 arg1 = reinterpret_cast< wxWindow * >(argp1);
31608 {
31609 PyThreadState* __tstate = wxPyBeginAllowThreads();
31610 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31611 wxPyEndAllowThreads(__tstate);
31612 if (PyErr_Occurred()) SWIG_fail;
31613 }
31614 resultobj = SWIG_From_int(static_cast< int >(result));
31615 return resultobj;
31616 fail:
31617 return NULL;
31618 }
31619
31620
31621 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31622 PyObject *resultobj = 0;
31623 wxWindow *arg1 = (wxWindow *) 0 ;
31624 int result;
31625 void *argp1 = 0 ;
31626 int res1 = 0 ;
31627 PyObject *swig_obj[1] ;
31628
31629 if (!args) SWIG_fail;
31630 swig_obj[0] = args;
31631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31632 if (!SWIG_IsOK(res1)) {
31633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31634 }
31635 arg1 = reinterpret_cast< wxWindow * >(argp1);
31636 {
31637 PyThreadState* __tstate = wxPyBeginAllowThreads();
31638 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31639 wxPyEndAllowThreads(__tstate);
31640 if (PyErr_Occurred()) SWIG_fail;
31641 }
31642 resultobj = SWIG_From_int(static_cast< int >(result));
31643 return resultobj;
31644 fail:
31645 return NULL;
31646 }
31647
31648
31649 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31650 PyObject *resultobj = 0;
31651 wxWindow *arg1 = (wxWindow *) 0 ;
31652 wxSize *arg2 = 0 ;
31653 void *argp1 = 0 ;
31654 int res1 = 0 ;
31655 wxSize temp2 ;
31656 PyObject * obj0 = 0 ;
31657 PyObject * obj1 = 0 ;
31658 char * kwnames[] = {
31659 (char *) "self",(char *) "size", NULL
31660 };
31661
31662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31664 if (!SWIG_IsOK(res1)) {
31665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31666 }
31667 arg1 = reinterpret_cast< wxWindow * >(argp1);
31668 {
31669 arg2 = &temp2;
31670 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31671 }
31672 {
31673 PyThreadState* __tstate = wxPyBeginAllowThreads();
31674 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31675 wxPyEndAllowThreads(__tstate);
31676 if (PyErr_Occurred()) SWIG_fail;
31677 }
31678 resultobj = SWIG_Py_Void();
31679 return resultobj;
31680 fail:
31681 return NULL;
31682 }
31683
31684
31685 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31686 PyObject *resultobj = 0;
31687 wxWindow *arg1 = (wxWindow *) 0 ;
31688 int arg2 ;
31689 int arg3 ;
31690 void *argp1 = 0 ;
31691 int res1 = 0 ;
31692 int val2 ;
31693 int ecode2 = 0 ;
31694 int val3 ;
31695 int ecode3 = 0 ;
31696 PyObject * obj0 = 0 ;
31697 PyObject * obj1 = 0 ;
31698 PyObject * obj2 = 0 ;
31699 char * kwnames[] = {
31700 (char *) "self",(char *) "w",(char *) "h", NULL
31701 };
31702
31703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31705 if (!SWIG_IsOK(res1)) {
31706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31707 }
31708 arg1 = reinterpret_cast< wxWindow * >(argp1);
31709 ecode2 = SWIG_AsVal_int(obj1, &val2);
31710 if (!SWIG_IsOK(ecode2)) {
31711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31712 }
31713 arg2 = static_cast< int >(val2);
31714 ecode3 = SWIG_AsVal_int(obj2, &val3);
31715 if (!SWIG_IsOK(ecode3)) {
31716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31717 }
31718 arg3 = static_cast< int >(val3);
31719 {
31720 PyThreadState* __tstate = wxPyBeginAllowThreads();
31721 (arg1)->SetVirtualSize(arg2,arg3);
31722 wxPyEndAllowThreads(__tstate);
31723 if (PyErr_Occurred()) SWIG_fail;
31724 }
31725 resultobj = SWIG_Py_Void();
31726 return resultobj;
31727 fail:
31728 return NULL;
31729 }
31730
31731
31732 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31733 PyObject *resultobj = 0;
31734 wxWindow *arg1 = (wxWindow *) 0 ;
31735 wxSize result;
31736 void *argp1 = 0 ;
31737 int res1 = 0 ;
31738 PyObject *swig_obj[1] ;
31739
31740 if (!args) SWIG_fail;
31741 swig_obj[0] = args;
31742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31743 if (!SWIG_IsOK(res1)) {
31744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31745 }
31746 arg1 = reinterpret_cast< wxWindow * >(argp1);
31747 {
31748 PyThreadState* __tstate = wxPyBeginAllowThreads();
31749 result = ((wxWindow const *)arg1)->GetVirtualSize();
31750 wxPyEndAllowThreads(__tstate);
31751 if (PyErr_Occurred()) SWIG_fail;
31752 }
31753 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31754 return resultobj;
31755 fail:
31756 return NULL;
31757 }
31758
31759
31760 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31761 PyObject *resultobj = 0;
31762 wxWindow *arg1 = (wxWindow *) 0 ;
31763 int *arg2 = (int *) 0 ;
31764 int *arg3 = (int *) 0 ;
31765 void *argp1 = 0 ;
31766 int res1 = 0 ;
31767 int temp2 ;
31768 int res2 = SWIG_TMPOBJ ;
31769 int temp3 ;
31770 int res3 = SWIG_TMPOBJ ;
31771 PyObject *swig_obj[1] ;
31772
31773 arg2 = &temp2;
31774 arg3 = &temp3;
31775 if (!args) SWIG_fail;
31776 swig_obj[0] = args;
31777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31778 if (!SWIG_IsOK(res1)) {
31779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31780 }
31781 arg1 = reinterpret_cast< wxWindow * >(argp1);
31782 {
31783 PyThreadState* __tstate = wxPyBeginAllowThreads();
31784 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31785 wxPyEndAllowThreads(__tstate);
31786 if (PyErr_Occurred()) SWIG_fail;
31787 }
31788 resultobj = SWIG_Py_Void();
31789 if (SWIG_IsTmpObj(res2)) {
31790 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31791 } else {
31792 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31793 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31794 }
31795 if (SWIG_IsTmpObj(res3)) {
31796 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31797 } else {
31798 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31800 }
31801 return resultobj;
31802 fail:
31803 return NULL;
31804 }
31805
31806
31807 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31808 PyObject *resultobj = 0;
31809 wxWindow *arg1 = (wxWindow *) 0 ;
31810 wxSize result;
31811 void *argp1 = 0 ;
31812 int res1 = 0 ;
31813 PyObject *swig_obj[1] ;
31814
31815 if (!args) SWIG_fail;
31816 swig_obj[0] = args;
31817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31818 if (!SWIG_IsOK(res1)) {
31819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31820 }
31821 arg1 = reinterpret_cast< wxWindow * >(argp1);
31822 {
31823 PyThreadState* __tstate = wxPyBeginAllowThreads();
31824 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
31825 wxPyEndAllowThreads(__tstate);
31826 if (PyErr_Occurred()) SWIG_fail;
31827 }
31828 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31829 return resultobj;
31830 fail:
31831 return NULL;
31832 }
31833
31834
31835 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31836 PyObject *resultobj = 0;
31837 wxWindow *arg1 = (wxWindow *) 0 ;
31838 bool arg2 = (bool) true ;
31839 bool result;
31840 void *argp1 = 0 ;
31841 int res1 = 0 ;
31842 bool val2 ;
31843 int ecode2 = 0 ;
31844 PyObject * obj0 = 0 ;
31845 PyObject * obj1 = 0 ;
31846 char * kwnames[] = {
31847 (char *) "self",(char *) "show", NULL
31848 };
31849
31850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
31851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31852 if (!SWIG_IsOK(res1)) {
31853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
31854 }
31855 arg1 = reinterpret_cast< wxWindow * >(argp1);
31856 if (obj1) {
31857 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31858 if (!SWIG_IsOK(ecode2)) {
31859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
31860 }
31861 arg2 = static_cast< bool >(val2);
31862 }
31863 {
31864 PyThreadState* __tstate = wxPyBeginAllowThreads();
31865 result = (bool)(arg1)->Show(arg2);
31866 wxPyEndAllowThreads(__tstate);
31867 if (PyErr_Occurred()) SWIG_fail;
31868 }
31869 {
31870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31871 }
31872 return resultobj;
31873 fail:
31874 return NULL;
31875 }
31876
31877
31878 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31879 PyObject *resultobj = 0;
31880 wxWindow *arg1 = (wxWindow *) 0 ;
31881 bool result;
31882 void *argp1 = 0 ;
31883 int res1 = 0 ;
31884 PyObject *swig_obj[1] ;
31885
31886 if (!args) SWIG_fail;
31887 swig_obj[0] = args;
31888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31889 if (!SWIG_IsOK(res1)) {
31890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
31891 }
31892 arg1 = reinterpret_cast< wxWindow * >(argp1);
31893 {
31894 PyThreadState* __tstate = wxPyBeginAllowThreads();
31895 result = (bool)(arg1)->Hide();
31896 wxPyEndAllowThreads(__tstate);
31897 if (PyErr_Occurred()) SWIG_fail;
31898 }
31899 {
31900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31901 }
31902 return resultobj;
31903 fail:
31904 return NULL;
31905 }
31906
31907
31908 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31909 PyObject *resultobj = 0;
31910 wxWindow *arg1 = (wxWindow *) 0 ;
31911 bool arg2 = (bool) true ;
31912 bool result;
31913 void *argp1 = 0 ;
31914 int res1 = 0 ;
31915 bool val2 ;
31916 int ecode2 = 0 ;
31917 PyObject * obj0 = 0 ;
31918 PyObject * obj1 = 0 ;
31919 char * kwnames[] = {
31920 (char *) "self",(char *) "enable", NULL
31921 };
31922
31923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
31924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31925 if (!SWIG_IsOK(res1)) {
31926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
31927 }
31928 arg1 = reinterpret_cast< wxWindow * >(argp1);
31929 if (obj1) {
31930 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31931 if (!SWIG_IsOK(ecode2)) {
31932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
31933 }
31934 arg2 = static_cast< bool >(val2);
31935 }
31936 {
31937 PyThreadState* __tstate = wxPyBeginAllowThreads();
31938 result = (bool)(arg1)->Enable(arg2);
31939 wxPyEndAllowThreads(__tstate);
31940 if (PyErr_Occurred()) SWIG_fail;
31941 }
31942 {
31943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31944 }
31945 return resultobj;
31946 fail:
31947 return NULL;
31948 }
31949
31950
31951 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31952 PyObject *resultobj = 0;
31953 wxWindow *arg1 = (wxWindow *) 0 ;
31954 bool result;
31955 void *argp1 = 0 ;
31956 int res1 = 0 ;
31957 PyObject *swig_obj[1] ;
31958
31959 if (!args) SWIG_fail;
31960 swig_obj[0] = args;
31961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31962 if (!SWIG_IsOK(res1)) {
31963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
31964 }
31965 arg1 = reinterpret_cast< wxWindow * >(argp1);
31966 {
31967 PyThreadState* __tstate = wxPyBeginAllowThreads();
31968 result = (bool)(arg1)->Disable();
31969 wxPyEndAllowThreads(__tstate);
31970 if (PyErr_Occurred()) SWIG_fail;
31971 }
31972 {
31973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31974 }
31975 return resultobj;
31976 fail:
31977 return NULL;
31978 }
31979
31980
31981 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31982 PyObject *resultobj = 0;
31983 wxWindow *arg1 = (wxWindow *) 0 ;
31984 bool result;
31985 void *argp1 = 0 ;
31986 int res1 = 0 ;
31987 PyObject *swig_obj[1] ;
31988
31989 if (!args) SWIG_fail;
31990 swig_obj[0] = args;
31991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31992 if (!SWIG_IsOK(res1)) {
31993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
31994 }
31995 arg1 = reinterpret_cast< wxWindow * >(argp1);
31996 {
31997 PyThreadState* __tstate = wxPyBeginAllowThreads();
31998 result = (bool)((wxWindow const *)arg1)->IsShown();
31999 wxPyEndAllowThreads(__tstate);
32000 if (PyErr_Occurred()) SWIG_fail;
32001 }
32002 {
32003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32004 }
32005 return resultobj;
32006 fail:
32007 return NULL;
32008 }
32009
32010
32011 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32012 PyObject *resultobj = 0;
32013 wxWindow *arg1 = (wxWindow *) 0 ;
32014 bool result;
32015 void *argp1 = 0 ;
32016 int res1 = 0 ;
32017 PyObject *swig_obj[1] ;
32018
32019 if (!args) SWIG_fail;
32020 swig_obj[0] = args;
32021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32022 if (!SWIG_IsOK(res1)) {
32023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32024 }
32025 arg1 = reinterpret_cast< wxWindow * >(argp1);
32026 {
32027 PyThreadState* __tstate = wxPyBeginAllowThreads();
32028 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32029 wxPyEndAllowThreads(__tstate);
32030 if (PyErr_Occurred()) SWIG_fail;
32031 }
32032 {
32033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32034 }
32035 return resultobj;
32036 fail:
32037 return NULL;
32038 }
32039
32040
32041 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32042 PyObject *resultobj = 0;
32043 wxWindow *arg1 = (wxWindow *) 0 ;
32044 long arg2 ;
32045 void *argp1 = 0 ;
32046 int res1 = 0 ;
32047 long val2 ;
32048 int ecode2 = 0 ;
32049 PyObject * obj0 = 0 ;
32050 PyObject * obj1 = 0 ;
32051 char * kwnames[] = {
32052 (char *) "self",(char *) "style", NULL
32053 };
32054
32055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32057 if (!SWIG_IsOK(res1)) {
32058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32059 }
32060 arg1 = reinterpret_cast< wxWindow * >(argp1);
32061 ecode2 = SWIG_AsVal_long(obj1, &val2);
32062 if (!SWIG_IsOK(ecode2)) {
32063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32064 }
32065 arg2 = static_cast< long >(val2);
32066 {
32067 PyThreadState* __tstate = wxPyBeginAllowThreads();
32068 (arg1)->SetWindowStyleFlag(arg2);
32069 wxPyEndAllowThreads(__tstate);
32070 if (PyErr_Occurred()) SWIG_fail;
32071 }
32072 resultobj = SWIG_Py_Void();
32073 return resultobj;
32074 fail:
32075 return NULL;
32076 }
32077
32078
32079 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32080 PyObject *resultobj = 0;
32081 wxWindow *arg1 = (wxWindow *) 0 ;
32082 long result;
32083 void *argp1 = 0 ;
32084 int res1 = 0 ;
32085 PyObject *swig_obj[1] ;
32086
32087 if (!args) SWIG_fail;
32088 swig_obj[0] = args;
32089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32090 if (!SWIG_IsOK(res1)) {
32091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32092 }
32093 arg1 = reinterpret_cast< wxWindow * >(argp1);
32094 {
32095 PyThreadState* __tstate = wxPyBeginAllowThreads();
32096 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32097 wxPyEndAllowThreads(__tstate);
32098 if (PyErr_Occurred()) SWIG_fail;
32099 }
32100 resultobj = SWIG_From_long(static_cast< long >(result));
32101 return resultobj;
32102 fail:
32103 return NULL;
32104 }
32105
32106
32107 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32108 PyObject *resultobj = 0;
32109 wxWindow *arg1 = (wxWindow *) 0 ;
32110 int arg2 ;
32111 bool result;
32112 void *argp1 = 0 ;
32113 int res1 = 0 ;
32114 int val2 ;
32115 int ecode2 = 0 ;
32116 PyObject * obj0 = 0 ;
32117 PyObject * obj1 = 0 ;
32118 char * kwnames[] = {
32119 (char *) "self",(char *) "flag", NULL
32120 };
32121
32122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32124 if (!SWIG_IsOK(res1)) {
32125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32126 }
32127 arg1 = reinterpret_cast< wxWindow * >(argp1);
32128 ecode2 = SWIG_AsVal_int(obj1, &val2);
32129 if (!SWIG_IsOK(ecode2)) {
32130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32131 }
32132 arg2 = static_cast< int >(val2);
32133 {
32134 PyThreadState* __tstate = wxPyBeginAllowThreads();
32135 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32136 wxPyEndAllowThreads(__tstate);
32137 if (PyErr_Occurred()) SWIG_fail;
32138 }
32139 {
32140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32141 }
32142 return resultobj;
32143 fail:
32144 return NULL;
32145 }
32146
32147
32148 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32149 PyObject *resultobj = 0;
32150 wxWindow *arg1 = (wxWindow *) 0 ;
32151 bool result;
32152 void *argp1 = 0 ;
32153 int res1 = 0 ;
32154 PyObject *swig_obj[1] ;
32155
32156 if (!args) SWIG_fail;
32157 swig_obj[0] = args;
32158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32159 if (!SWIG_IsOK(res1)) {
32160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32161 }
32162 arg1 = reinterpret_cast< wxWindow * >(argp1);
32163 {
32164 PyThreadState* __tstate = wxPyBeginAllowThreads();
32165 result = (bool)((wxWindow const *)arg1)->IsRetained();
32166 wxPyEndAllowThreads(__tstate);
32167 if (PyErr_Occurred()) SWIG_fail;
32168 }
32169 {
32170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32171 }
32172 return resultobj;
32173 fail:
32174 return NULL;
32175 }
32176
32177
32178 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32179 PyObject *resultobj = 0;
32180 wxWindow *arg1 = (wxWindow *) 0 ;
32181 long arg2 ;
32182 void *argp1 = 0 ;
32183 int res1 = 0 ;
32184 long val2 ;
32185 int ecode2 = 0 ;
32186 PyObject * obj0 = 0 ;
32187 PyObject * obj1 = 0 ;
32188 char * kwnames[] = {
32189 (char *) "self",(char *) "exStyle", NULL
32190 };
32191
32192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32194 if (!SWIG_IsOK(res1)) {
32195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32196 }
32197 arg1 = reinterpret_cast< wxWindow * >(argp1);
32198 ecode2 = SWIG_AsVal_long(obj1, &val2);
32199 if (!SWIG_IsOK(ecode2)) {
32200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32201 }
32202 arg2 = static_cast< long >(val2);
32203 {
32204 PyThreadState* __tstate = wxPyBeginAllowThreads();
32205 (arg1)->SetExtraStyle(arg2);
32206 wxPyEndAllowThreads(__tstate);
32207 if (PyErr_Occurred()) SWIG_fail;
32208 }
32209 resultobj = SWIG_Py_Void();
32210 return resultobj;
32211 fail:
32212 return NULL;
32213 }
32214
32215
32216 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32217 PyObject *resultobj = 0;
32218 wxWindow *arg1 = (wxWindow *) 0 ;
32219 long result;
32220 void *argp1 = 0 ;
32221 int res1 = 0 ;
32222 PyObject *swig_obj[1] ;
32223
32224 if (!args) SWIG_fail;
32225 swig_obj[0] = args;
32226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32227 if (!SWIG_IsOK(res1)) {
32228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32229 }
32230 arg1 = reinterpret_cast< wxWindow * >(argp1);
32231 {
32232 PyThreadState* __tstate = wxPyBeginAllowThreads();
32233 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32234 wxPyEndAllowThreads(__tstate);
32235 if (PyErr_Occurred()) SWIG_fail;
32236 }
32237 resultobj = SWIG_From_long(static_cast< long >(result));
32238 return resultobj;
32239 fail:
32240 return NULL;
32241 }
32242
32243
32244 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32245 PyObject *resultobj = 0;
32246 wxWindow *arg1 = (wxWindow *) 0 ;
32247 bool arg2 = (bool) true ;
32248 void *argp1 = 0 ;
32249 int res1 = 0 ;
32250 bool val2 ;
32251 int ecode2 = 0 ;
32252 PyObject * obj0 = 0 ;
32253 PyObject * obj1 = 0 ;
32254 char * kwnames[] = {
32255 (char *) "self",(char *) "modal", NULL
32256 };
32257
32258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32260 if (!SWIG_IsOK(res1)) {
32261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32262 }
32263 arg1 = reinterpret_cast< wxWindow * >(argp1);
32264 if (obj1) {
32265 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32266 if (!SWIG_IsOK(ecode2)) {
32267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32268 }
32269 arg2 = static_cast< bool >(val2);
32270 }
32271 {
32272 PyThreadState* __tstate = wxPyBeginAllowThreads();
32273 (arg1)->MakeModal(arg2);
32274 wxPyEndAllowThreads(__tstate);
32275 if (PyErr_Occurred()) SWIG_fail;
32276 }
32277 resultobj = SWIG_Py_Void();
32278 return resultobj;
32279 fail:
32280 return NULL;
32281 }
32282
32283
32284 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32285 PyObject *resultobj = 0;
32286 wxWindow *arg1 = (wxWindow *) 0 ;
32287 bool arg2 ;
32288 void *argp1 = 0 ;
32289 int res1 = 0 ;
32290 bool val2 ;
32291 int ecode2 = 0 ;
32292 PyObject * obj0 = 0 ;
32293 PyObject * obj1 = 0 ;
32294 char * kwnames[] = {
32295 (char *) "self",(char *) "enableTheme", NULL
32296 };
32297
32298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32300 if (!SWIG_IsOK(res1)) {
32301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32302 }
32303 arg1 = reinterpret_cast< wxWindow * >(argp1);
32304 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32305 if (!SWIG_IsOK(ecode2)) {
32306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32307 }
32308 arg2 = static_cast< bool >(val2);
32309 {
32310 PyThreadState* __tstate = wxPyBeginAllowThreads();
32311 (arg1)->SetThemeEnabled(arg2);
32312 wxPyEndAllowThreads(__tstate);
32313 if (PyErr_Occurred()) SWIG_fail;
32314 }
32315 resultobj = SWIG_Py_Void();
32316 return resultobj;
32317 fail:
32318 return NULL;
32319 }
32320
32321
32322 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32323 PyObject *resultobj = 0;
32324 wxWindow *arg1 = (wxWindow *) 0 ;
32325 bool result;
32326 void *argp1 = 0 ;
32327 int res1 = 0 ;
32328 PyObject *swig_obj[1] ;
32329
32330 if (!args) SWIG_fail;
32331 swig_obj[0] = args;
32332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32333 if (!SWIG_IsOK(res1)) {
32334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32335 }
32336 arg1 = reinterpret_cast< wxWindow * >(argp1);
32337 {
32338 PyThreadState* __tstate = wxPyBeginAllowThreads();
32339 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32340 wxPyEndAllowThreads(__tstate);
32341 if (PyErr_Occurred()) SWIG_fail;
32342 }
32343 {
32344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32345 }
32346 return resultobj;
32347 fail:
32348 return NULL;
32349 }
32350
32351
32352 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32353 PyObject *resultobj = 0;
32354 wxWindow *arg1 = (wxWindow *) 0 ;
32355 void *argp1 = 0 ;
32356 int res1 = 0 ;
32357 PyObject *swig_obj[1] ;
32358
32359 if (!args) SWIG_fail;
32360 swig_obj[0] = args;
32361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32362 if (!SWIG_IsOK(res1)) {
32363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32364 }
32365 arg1 = reinterpret_cast< wxWindow * >(argp1);
32366 {
32367 PyThreadState* __tstate = wxPyBeginAllowThreads();
32368 (arg1)->SetFocus();
32369 wxPyEndAllowThreads(__tstate);
32370 if (PyErr_Occurred()) SWIG_fail;
32371 }
32372 resultobj = SWIG_Py_Void();
32373 return resultobj;
32374 fail:
32375 return NULL;
32376 }
32377
32378
32379 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32380 PyObject *resultobj = 0;
32381 wxWindow *arg1 = (wxWindow *) 0 ;
32382 void *argp1 = 0 ;
32383 int res1 = 0 ;
32384 PyObject *swig_obj[1] ;
32385
32386 if (!args) SWIG_fail;
32387 swig_obj[0] = args;
32388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32389 if (!SWIG_IsOK(res1)) {
32390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32391 }
32392 arg1 = reinterpret_cast< wxWindow * >(argp1);
32393 {
32394 PyThreadState* __tstate = wxPyBeginAllowThreads();
32395 (arg1)->SetFocusFromKbd();
32396 wxPyEndAllowThreads(__tstate);
32397 if (PyErr_Occurred()) SWIG_fail;
32398 }
32399 resultobj = SWIG_Py_Void();
32400 return resultobj;
32401 fail:
32402 return NULL;
32403 }
32404
32405
32406 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32407 PyObject *resultobj = 0;
32408 wxWindow *result = 0 ;
32409
32410 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32411 {
32412 if (!wxPyCheckForApp()) SWIG_fail;
32413 PyThreadState* __tstate = wxPyBeginAllowThreads();
32414 result = (wxWindow *)wxWindow::FindFocus();
32415 wxPyEndAllowThreads(__tstate);
32416 if (PyErr_Occurred()) SWIG_fail;
32417 }
32418 {
32419 resultobj = wxPyMake_wxObject(result, 0);
32420 }
32421 return resultobj;
32422 fail:
32423 return NULL;
32424 }
32425
32426
32427 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32428 PyObject *resultobj = 0;
32429 wxWindow *arg1 = (wxWindow *) 0 ;
32430 bool result;
32431 void *argp1 = 0 ;
32432 int res1 = 0 ;
32433 PyObject *swig_obj[1] ;
32434
32435 if (!args) SWIG_fail;
32436 swig_obj[0] = args;
32437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32438 if (!SWIG_IsOK(res1)) {
32439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32440 }
32441 arg1 = reinterpret_cast< wxWindow * >(argp1);
32442 {
32443 PyThreadState* __tstate = wxPyBeginAllowThreads();
32444 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32445 wxPyEndAllowThreads(__tstate);
32446 if (PyErr_Occurred()) SWIG_fail;
32447 }
32448 {
32449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32450 }
32451 return resultobj;
32452 fail:
32453 return NULL;
32454 }
32455
32456
32457 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32458 PyObject *resultobj = 0;
32459 wxWindow *arg1 = (wxWindow *) 0 ;
32460 bool result;
32461 void *argp1 = 0 ;
32462 int res1 = 0 ;
32463 PyObject *swig_obj[1] ;
32464
32465 if (!args) SWIG_fail;
32466 swig_obj[0] = args;
32467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32468 if (!SWIG_IsOK(res1)) {
32469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32470 }
32471 arg1 = reinterpret_cast< wxWindow * >(argp1);
32472 {
32473 PyThreadState* __tstate = wxPyBeginAllowThreads();
32474 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32475 wxPyEndAllowThreads(__tstate);
32476 if (PyErr_Occurred()) SWIG_fail;
32477 }
32478 {
32479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32480 }
32481 return resultobj;
32482 fail:
32483 return NULL;
32484 }
32485
32486
32487 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32488 PyObject *resultobj = 0;
32489 wxWindow *arg1 = (wxWindow *) 0 ;
32490 wxWindow *result = 0 ;
32491 void *argp1 = 0 ;
32492 int res1 = 0 ;
32493 PyObject *swig_obj[1] ;
32494
32495 if (!args) SWIG_fail;
32496 swig_obj[0] = args;
32497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32498 if (!SWIG_IsOK(res1)) {
32499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32500 }
32501 arg1 = reinterpret_cast< wxWindow * >(argp1);
32502 {
32503 PyThreadState* __tstate = wxPyBeginAllowThreads();
32504 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32505 wxPyEndAllowThreads(__tstate);
32506 if (PyErr_Occurred()) SWIG_fail;
32507 }
32508 {
32509 resultobj = wxPyMake_wxObject(result, 0);
32510 }
32511 return resultobj;
32512 fail:
32513 return NULL;
32514 }
32515
32516
32517 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32518 PyObject *resultobj = 0;
32519 wxWindow *arg1 = (wxWindow *) 0 ;
32520 wxWindow *arg2 = (wxWindow *) 0 ;
32521 wxWindow *result = 0 ;
32522 void *argp1 = 0 ;
32523 int res1 = 0 ;
32524 void *argp2 = 0 ;
32525 int res2 = 0 ;
32526 PyObject * obj0 = 0 ;
32527 PyObject * obj1 = 0 ;
32528 char * kwnames[] = {
32529 (char *) "self",(char *) "child", NULL
32530 };
32531
32532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32534 if (!SWIG_IsOK(res1)) {
32535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32536 }
32537 arg1 = reinterpret_cast< wxWindow * >(argp1);
32538 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32539 if (!SWIG_IsOK(res2)) {
32540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32541 }
32542 arg2 = reinterpret_cast< wxWindow * >(argp2);
32543 {
32544 PyThreadState* __tstate = wxPyBeginAllowThreads();
32545 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32546 wxPyEndAllowThreads(__tstate);
32547 if (PyErr_Occurred()) SWIG_fail;
32548 }
32549 {
32550 resultobj = wxPyMake_wxObject(result, 0);
32551 }
32552 return resultobj;
32553 fail:
32554 return NULL;
32555 }
32556
32557
32558 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32559 PyObject *resultobj = 0;
32560 wxWindow *arg1 = (wxWindow *) 0 ;
32561 wxWindow *arg2 = (wxWindow *) 0 ;
32562 void *argp1 = 0 ;
32563 int res1 = 0 ;
32564 void *argp2 = 0 ;
32565 int res2 = 0 ;
32566 PyObject * obj0 = 0 ;
32567 PyObject * obj1 = 0 ;
32568 char * kwnames[] = {
32569 (char *) "self",(char *) "win", NULL
32570 };
32571
32572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32574 if (!SWIG_IsOK(res1)) {
32575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32576 }
32577 arg1 = reinterpret_cast< wxWindow * >(argp1);
32578 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32579 if (!SWIG_IsOK(res2)) {
32580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32581 }
32582 arg2 = reinterpret_cast< wxWindow * >(argp2);
32583 {
32584 PyThreadState* __tstate = wxPyBeginAllowThreads();
32585 (arg1)->SetTmpDefaultItem(arg2);
32586 wxPyEndAllowThreads(__tstate);
32587 if (PyErr_Occurred()) SWIG_fail;
32588 }
32589 resultobj = SWIG_Py_Void();
32590 return resultobj;
32591 fail:
32592 return NULL;
32593 }
32594
32595
32596 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32597 PyObject *resultobj = 0;
32598 wxWindow *arg1 = (wxWindow *) 0 ;
32599 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32600 bool result;
32601 void *argp1 = 0 ;
32602 int res1 = 0 ;
32603 int val2 ;
32604 int ecode2 = 0 ;
32605 PyObject * obj0 = 0 ;
32606 PyObject * obj1 = 0 ;
32607 char * kwnames[] = {
32608 (char *) "self",(char *) "flags", NULL
32609 };
32610
32611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",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_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32615 }
32616 arg1 = reinterpret_cast< wxWindow * >(argp1);
32617 if (obj1) {
32618 ecode2 = SWIG_AsVal_int(obj1, &val2);
32619 if (!SWIG_IsOK(ecode2)) {
32620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32621 }
32622 arg2 = static_cast< int >(val2);
32623 }
32624 {
32625 PyThreadState* __tstate = wxPyBeginAllowThreads();
32626 result = (bool)(arg1)->Navigate(arg2);
32627 wxPyEndAllowThreads(__tstate);
32628 if (PyErr_Occurred()) SWIG_fail;
32629 }
32630 {
32631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32632 }
32633 return resultobj;
32634 fail:
32635 return NULL;
32636 }
32637
32638
32639 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32640 PyObject *resultobj = 0;
32641 wxWindow *arg1 = (wxWindow *) 0 ;
32642 wxWindow *arg2 = (wxWindow *) 0 ;
32643 void *argp1 = 0 ;
32644 int res1 = 0 ;
32645 void *argp2 = 0 ;
32646 int res2 = 0 ;
32647 PyObject * obj0 = 0 ;
32648 PyObject * obj1 = 0 ;
32649 char * kwnames[] = {
32650 (char *) "self",(char *) "win", NULL
32651 };
32652
32653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32655 if (!SWIG_IsOK(res1)) {
32656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32657 }
32658 arg1 = reinterpret_cast< wxWindow * >(argp1);
32659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32660 if (!SWIG_IsOK(res2)) {
32661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32662 }
32663 arg2 = reinterpret_cast< wxWindow * >(argp2);
32664 {
32665 PyThreadState* __tstate = wxPyBeginAllowThreads();
32666 (arg1)->MoveAfterInTabOrder(arg2);
32667 wxPyEndAllowThreads(__tstate);
32668 if (PyErr_Occurred()) SWIG_fail;
32669 }
32670 resultobj = SWIG_Py_Void();
32671 return resultobj;
32672 fail:
32673 return NULL;
32674 }
32675
32676
32677 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32678 PyObject *resultobj = 0;
32679 wxWindow *arg1 = (wxWindow *) 0 ;
32680 wxWindow *arg2 = (wxWindow *) 0 ;
32681 void *argp1 = 0 ;
32682 int res1 = 0 ;
32683 void *argp2 = 0 ;
32684 int res2 = 0 ;
32685 PyObject * obj0 = 0 ;
32686 PyObject * obj1 = 0 ;
32687 char * kwnames[] = {
32688 (char *) "self",(char *) "win", NULL
32689 };
32690
32691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32693 if (!SWIG_IsOK(res1)) {
32694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32695 }
32696 arg1 = reinterpret_cast< wxWindow * >(argp1);
32697 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32698 if (!SWIG_IsOK(res2)) {
32699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32700 }
32701 arg2 = reinterpret_cast< wxWindow * >(argp2);
32702 {
32703 PyThreadState* __tstate = wxPyBeginAllowThreads();
32704 (arg1)->MoveBeforeInTabOrder(arg2);
32705 wxPyEndAllowThreads(__tstate);
32706 if (PyErr_Occurred()) SWIG_fail;
32707 }
32708 resultobj = SWIG_Py_Void();
32709 return resultobj;
32710 fail:
32711 return NULL;
32712 }
32713
32714
32715 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32716 PyObject *resultobj = 0;
32717 wxWindow *arg1 = (wxWindow *) 0 ;
32718 PyObject *result = 0 ;
32719 void *argp1 = 0 ;
32720 int res1 = 0 ;
32721 PyObject *swig_obj[1] ;
32722
32723 if (!args) SWIG_fail;
32724 swig_obj[0] = args;
32725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32726 if (!SWIG_IsOK(res1)) {
32727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32728 }
32729 arg1 = reinterpret_cast< wxWindow * >(argp1);
32730 {
32731 PyThreadState* __tstate = wxPyBeginAllowThreads();
32732 result = (PyObject *)wxWindow_GetChildren(arg1);
32733 wxPyEndAllowThreads(__tstate);
32734 if (PyErr_Occurred()) SWIG_fail;
32735 }
32736 resultobj = result;
32737 return resultobj;
32738 fail:
32739 return NULL;
32740 }
32741
32742
32743 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32744 PyObject *resultobj = 0;
32745 wxWindow *arg1 = (wxWindow *) 0 ;
32746 wxWindow *result = 0 ;
32747 void *argp1 = 0 ;
32748 int res1 = 0 ;
32749 PyObject *swig_obj[1] ;
32750
32751 if (!args) SWIG_fail;
32752 swig_obj[0] = args;
32753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32754 if (!SWIG_IsOK(res1)) {
32755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32756 }
32757 arg1 = reinterpret_cast< wxWindow * >(argp1);
32758 {
32759 PyThreadState* __tstate = wxPyBeginAllowThreads();
32760 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32761 wxPyEndAllowThreads(__tstate);
32762 if (PyErr_Occurred()) SWIG_fail;
32763 }
32764 {
32765 resultobj = wxPyMake_wxObject(result, 0);
32766 }
32767 return resultobj;
32768 fail:
32769 return NULL;
32770 }
32771
32772
32773 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32774 PyObject *resultobj = 0;
32775 wxWindow *arg1 = (wxWindow *) 0 ;
32776 wxWindow *result = 0 ;
32777 void *argp1 = 0 ;
32778 int res1 = 0 ;
32779 PyObject *swig_obj[1] ;
32780
32781 if (!args) SWIG_fail;
32782 swig_obj[0] = args;
32783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32784 if (!SWIG_IsOK(res1)) {
32785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32786 }
32787 arg1 = reinterpret_cast< wxWindow * >(argp1);
32788 {
32789 PyThreadState* __tstate = wxPyBeginAllowThreads();
32790 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32791 wxPyEndAllowThreads(__tstate);
32792 if (PyErr_Occurred()) SWIG_fail;
32793 }
32794 {
32795 resultobj = wxPyMake_wxObject(result, 0);
32796 }
32797 return resultobj;
32798 fail:
32799 return NULL;
32800 }
32801
32802
32803 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32804 PyObject *resultobj = 0;
32805 wxWindow *arg1 = (wxWindow *) 0 ;
32806 bool result;
32807 void *argp1 = 0 ;
32808 int res1 = 0 ;
32809 PyObject *swig_obj[1] ;
32810
32811 if (!args) SWIG_fail;
32812 swig_obj[0] = args;
32813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32814 if (!SWIG_IsOK(res1)) {
32815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
32816 }
32817 arg1 = reinterpret_cast< wxWindow * >(argp1);
32818 {
32819 PyThreadState* __tstate = wxPyBeginAllowThreads();
32820 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
32821 wxPyEndAllowThreads(__tstate);
32822 if (PyErr_Occurred()) SWIG_fail;
32823 }
32824 {
32825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32826 }
32827 return resultobj;
32828 fail:
32829 return NULL;
32830 }
32831
32832
32833 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32834 PyObject *resultobj = 0;
32835 wxWindow *arg1 = (wxWindow *) 0 ;
32836 wxWindow *arg2 = (wxWindow *) 0 ;
32837 bool result;
32838 void *argp1 = 0 ;
32839 int res1 = 0 ;
32840 void *argp2 = 0 ;
32841 int res2 = 0 ;
32842 PyObject * obj0 = 0 ;
32843 PyObject * obj1 = 0 ;
32844 char * kwnames[] = {
32845 (char *) "self",(char *) "newParent", NULL
32846 };
32847
32848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
32849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32850 if (!SWIG_IsOK(res1)) {
32851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
32852 }
32853 arg1 = reinterpret_cast< wxWindow * >(argp1);
32854 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32855 if (!SWIG_IsOK(res2)) {
32856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
32857 }
32858 arg2 = reinterpret_cast< wxWindow * >(argp2);
32859 {
32860 PyThreadState* __tstate = wxPyBeginAllowThreads();
32861 result = (bool)(arg1)->Reparent(arg2);
32862 wxPyEndAllowThreads(__tstate);
32863 if (PyErr_Occurred()) SWIG_fail;
32864 }
32865 {
32866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32867 }
32868 return resultobj;
32869 fail:
32870 return NULL;
32871 }
32872
32873
32874 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32875 PyObject *resultobj = 0;
32876 wxWindow *arg1 = (wxWindow *) 0 ;
32877 wxWindow *arg2 = (wxWindow *) 0 ;
32878 void *argp1 = 0 ;
32879 int res1 = 0 ;
32880 void *argp2 = 0 ;
32881 int res2 = 0 ;
32882 PyObject * obj0 = 0 ;
32883 PyObject * obj1 = 0 ;
32884 char * kwnames[] = {
32885 (char *) "self",(char *) "child", NULL
32886 };
32887
32888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
32889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32890 if (!SWIG_IsOK(res1)) {
32891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
32892 }
32893 arg1 = reinterpret_cast< wxWindow * >(argp1);
32894 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32895 if (!SWIG_IsOK(res2)) {
32896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
32897 }
32898 arg2 = reinterpret_cast< wxWindow * >(argp2);
32899 {
32900 PyThreadState* __tstate = wxPyBeginAllowThreads();
32901 (arg1)->AddChild(arg2);
32902 wxPyEndAllowThreads(__tstate);
32903 if (PyErr_Occurred()) SWIG_fail;
32904 }
32905 resultobj = SWIG_Py_Void();
32906 return resultobj;
32907 fail:
32908 return NULL;
32909 }
32910
32911
32912 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32913 PyObject *resultobj = 0;
32914 wxWindow *arg1 = (wxWindow *) 0 ;
32915 wxWindow *arg2 = (wxWindow *) 0 ;
32916 void *argp1 = 0 ;
32917 int res1 = 0 ;
32918 void *argp2 = 0 ;
32919 int res2 = 0 ;
32920 PyObject * obj0 = 0 ;
32921 PyObject * obj1 = 0 ;
32922 char * kwnames[] = {
32923 (char *) "self",(char *) "child", NULL
32924 };
32925
32926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
32927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32928 if (!SWIG_IsOK(res1)) {
32929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
32930 }
32931 arg1 = reinterpret_cast< wxWindow * >(argp1);
32932 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32933 if (!SWIG_IsOK(res2)) {
32934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
32935 }
32936 arg2 = reinterpret_cast< wxWindow * >(argp2);
32937 {
32938 PyThreadState* __tstate = wxPyBeginAllowThreads();
32939 (arg1)->RemoveChild(arg2);
32940 wxPyEndAllowThreads(__tstate);
32941 if (PyErr_Occurred()) SWIG_fail;
32942 }
32943 resultobj = SWIG_Py_Void();
32944 return resultobj;
32945 fail:
32946 return NULL;
32947 }
32948
32949
32950 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32951 PyObject *resultobj = 0;
32952 wxWindow *arg1 = (wxWindow *) 0 ;
32953 long arg2 ;
32954 wxWindow *result = 0 ;
32955 void *argp1 = 0 ;
32956 int res1 = 0 ;
32957 long val2 ;
32958 int ecode2 = 0 ;
32959 PyObject * obj0 = 0 ;
32960 PyObject * obj1 = 0 ;
32961 char * kwnames[] = {
32962 (char *) "self",(char *) "winid", NULL
32963 };
32964
32965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
32966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32967 if (!SWIG_IsOK(res1)) {
32968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
32969 }
32970 arg1 = reinterpret_cast< wxWindow * >(argp1);
32971 ecode2 = SWIG_AsVal_long(obj1, &val2);
32972 if (!SWIG_IsOK(ecode2)) {
32973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
32974 }
32975 arg2 = static_cast< long >(val2);
32976 {
32977 PyThreadState* __tstate = wxPyBeginAllowThreads();
32978 result = (wxWindow *)(arg1)->FindWindow(arg2);
32979 wxPyEndAllowThreads(__tstate);
32980 if (PyErr_Occurred()) SWIG_fail;
32981 }
32982 {
32983 resultobj = wxPyMake_wxObject(result, 0);
32984 }
32985 return resultobj;
32986 fail:
32987 return NULL;
32988 }
32989
32990
32991 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32992 PyObject *resultobj = 0;
32993 wxWindow *arg1 = (wxWindow *) 0 ;
32994 wxString *arg2 = 0 ;
32995 wxWindow *result = 0 ;
32996 void *argp1 = 0 ;
32997 int res1 = 0 ;
32998 bool temp2 = false ;
32999 PyObject * obj0 = 0 ;
33000 PyObject * obj1 = 0 ;
33001 char * kwnames[] = {
33002 (char *) "self",(char *) "name", NULL
33003 };
33004
33005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33007 if (!SWIG_IsOK(res1)) {
33008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33009 }
33010 arg1 = reinterpret_cast< wxWindow * >(argp1);
33011 {
33012 arg2 = wxString_in_helper(obj1);
33013 if (arg2 == NULL) SWIG_fail;
33014 temp2 = true;
33015 }
33016 {
33017 PyThreadState* __tstate = wxPyBeginAllowThreads();
33018 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33019 wxPyEndAllowThreads(__tstate);
33020 if (PyErr_Occurred()) SWIG_fail;
33021 }
33022 {
33023 resultobj = wxPyMake_wxObject(result, 0);
33024 }
33025 {
33026 if (temp2)
33027 delete arg2;
33028 }
33029 return resultobj;
33030 fail:
33031 {
33032 if (temp2)
33033 delete arg2;
33034 }
33035 return NULL;
33036 }
33037
33038
33039 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33040 PyObject *resultobj = 0;
33041 wxWindow *arg1 = (wxWindow *) 0 ;
33042 wxEvtHandler *result = 0 ;
33043 void *argp1 = 0 ;
33044 int res1 = 0 ;
33045 PyObject *swig_obj[1] ;
33046
33047 if (!args) SWIG_fail;
33048 swig_obj[0] = args;
33049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33050 if (!SWIG_IsOK(res1)) {
33051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33052 }
33053 arg1 = reinterpret_cast< wxWindow * >(argp1);
33054 {
33055 PyThreadState* __tstate = wxPyBeginAllowThreads();
33056 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33057 wxPyEndAllowThreads(__tstate);
33058 if (PyErr_Occurred()) SWIG_fail;
33059 }
33060 {
33061 resultobj = wxPyMake_wxObject(result, 0);
33062 }
33063 return resultobj;
33064 fail:
33065 return NULL;
33066 }
33067
33068
33069 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33070 PyObject *resultobj = 0;
33071 wxWindow *arg1 = (wxWindow *) 0 ;
33072 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33073 void *argp1 = 0 ;
33074 int res1 = 0 ;
33075 void *argp2 = 0 ;
33076 int res2 = 0 ;
33077 PyObject * obj0 = 0 ;
33078 PyObject * obj1 = 0 ;
33079 char * kwnames[] = {
33080 (char *) "self",(char *) "handler", NULL
33081 };
33082
33083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33085 if (!SWIG_IsOK(res1)) {
33086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33087 }
33088 arg1 = reinterpret_cast< wxWindow * >(argp1);
33089 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33090 if (!SWIG_IsOK(res2)) {
33091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33092 }
33093 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33094 {
33095 PyThreadState* __tstate = wxPyBeginAllowThreads();
33096 (arg1)->SetEventHandler(arg2);
33097 wxPyEndAllowThreads(__tstate);
33098 if (PyErr_Occurred()) SWIG_fail;
33099 }
33100 resultobj = SWIG_Py_Void();
33101 return resultobj;
33102 fail:
33103 return NULL;
33104 }
33105
33106
33107 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33108 PyObject *resultobj = 0;
33109 wxWindow *arg1 = (wxWindow *) 0 ;
33110 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33111 void *argp1 = 0 ;
33112 int res1 = 0 ;
33113 void *argp2 = 0 ;
33114 int res2 = 0 ;
33115 PyObject * obj0 = 0 ;
33116 PyObject * obj1 = 0 ;
33117 char * kwnames[] = {
33118 (char *) "self",(char *) "handler", NULL
33119 };
33120
33121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33123 if (!SWIG_IsOK(res1)) {
33124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33125 }
33126 arg1 = reinterpret_cast< wxWindow * >(argp1);
33127 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33128 if (!SWIG_IsOK(res2)) {
33129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33130 }
33131 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33132 {
33133 PyThreadState* __tstate = wxPyBeginAllowThreads();
33134 (arg1)->PushEventHandler(arg2);
33135 wxPyEndAllowThreads(__tstate);
33136 if (PyErr_Occurred()) SWIG_fail;
33137 }
33138 resultobj = SWIG_Py_Void();
33139 return resultobj;
33140 fail:
33141 return NULL;
33142 }
33143
33144
33145 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33146 PyObject *resultobj = 0;
33147 wxWindow *arg1 = (wxWindow *) 0 ;
33148 bool arg2 = (bool) false ;
33149 wxEvtHandler *result = 0 ;
33150 void *argp1 = 0 ;
33151 int res1 = 0 ;
33152 bool val2 ;
33153 int ecode2 = 0 ;
33154 PyObject * obj0 = 0 ;
33155 PyObject * obj1 = 0 ;
33156 char * kwnames[] = {
33157 (char *) "self",(char *) "deleteHandler", NULL
33158 };
33159
33160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33162 if (!SWIG_IsOK(res1)) {
33163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33164 }
33165 arg1 = reinterpret_cast< wxWindow * >(argp1);
33166 if (obj1) {
33167 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33168 if (!SWIG_IsOK(ecode2)) {
33169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33170 }
33171 arg2 = static_cast< bool >(val2);
33172 }
33173 {
33174 PyThreadState* __tstate = wxPyBeginAllowThreads();
33175 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33176 wxPyEndAllowThreads(__tstate);
33177 if (PyErr_Occurred()) SWIG_fail;
33178 }
33179 {
33180 resultobj = wxPyMake_wxObject(result, 0);
33181 }
33182 return resultobj;
33183 fail:
33184 return NULL;
33185 }
33186
33187
33188 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33189 PyObject *resultobj = 0;
33190 wxWindow *arg1 = (wxWindow *) 0 ;
33191 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33192 bool result;
33193 void *argp1 = 0 ;
33194 int res1 = 0 ;
33195 void *argp2 = 0 ;
33196 int res2 = 0 ;
33197 PyObject * obj0 = 0 ;
33198 PyObject * obj1 = 0 ;
33199 char * kwnames[] = {
33200 (char *) "self",(char *) "handler", NULL
33201 };
33202
33203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33205 if (!SWIG_IsOK(res1)) {
33206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33207 }
33208 arg1 = reinterpret_cast< wxWindow * >(argp1);
33209 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33210 if (!SWIG_IsOK(res2)) {
33211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33212 }
33213 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33214 {
33215 PyThreadState* __tstate = wxPyBeginAllowThreads();
33216 result = (bool)(arg1)->RemoveEventHandler(arg2);
33217 wxPyEndAllowThreads(__tstate);
33218 if (PyErr_Occurred()) SWIG_fail;
33219 }
33220 {
33221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33222 }
33223 return resultobj;
33224 fail:
33225 return NULL;
33226 }
33227
33228
33229 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33230 PyObject *resultobj = 0;
33231 wxWindow *arg1 = (wxWindow *) 0 ;
33232 wxValidator *arg2 = 0 ;
33233 void *argp1 = 0 ;
33234 int res1 = 0 ;
33235 void *argp2 = 0 ;
33236 int res2 = 0 ;
33237 PyObject * obj0 = 0 ;
33238 PyObject * obj1 = 0 ;
33239 char * kwnames[] = {
33240 (char *) "self",(char *) "validator", NULL
33241 };
33242
33243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33245 if (!SWIG_IsOK(res1)) {
33246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33247 }
33248 arg1 = reinterpret_cast< wxWindow * >(argp1);
33249 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33250 if (!SWIG_IsOK(res2)) {
33251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33252 }
33253 if (!argp2) {
33254 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33255 }
33256 arg2 = reinterpret_cast< wxValidator * >(argp2);
33257 {
33258 PyThreadState* __tstate = wxPyBeginAllowThreads();
33259 (arg1)->SetValidator((wxValidator const &)*arg2);
33260 wxPyEndAllowThreads(__tstate);
33261 if (PyErr_Occurred()) SWIG_fail;
33262 }
33263 resultobj = SWIG_Py_Void();
33264 return resultobj;
33265 fail:
33266 return NULL;
33267 }
33268
33269
33270 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33271 PyObject *resultobj = 0;
33272 wxWindow *arg1 = (wxWindow *) 0 ;
33273 wxValidator *result = 0 ;
33274 void *argp1 = 0 ;
33275 int res1 = 0 ;
33276 PyObject *swig_obj[1] ;
33277
33278 if (!args) SWIG_fail;
33279 swig_obj[0] = args;
33280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33281 if (!SWIG_IsOK(res1)) {
33282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33283 }
33284 arg1 = reinterpret_cast< wxWindow * >(argp1);
33285 {
33286 PyThreadState* __tstate = wxPyBeginAllowThreads();
33287 result = (wxValidator *)(arg1)->GetValidator();
33288 wxPyEndAllowThreads(__tstate);
33289 if (PyErr_Occurred()) SWIG_fail;
33290 }
33291 {
33292 resultobj = wxPyMake_wxObject(result, (bool)0);
33293 }
33294 return resultobj;
33295 fail:
33296 return NULL;
33297 }
33298
33299
33300 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33301 PyObject *resultobj = 0;
33302 wxWindow *arg1 = (wxWindow *) 0 ;
33303 bool result;
33304 void *argp1 = 0 ;
33305 int res1 = 0 ;
33306 PyObject *swig_obj[1] ;
33307
33308 if (!args) SWIG_fail;
33309 swig_obj[0] = args;
33310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33311 if (!SWIG_IsOK(res1)) {
33312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33313 }
33314 arg1 = reinterpret_cast< wxWindow * >(argp1);
33315 {
33316 PyThreadState* __tstate = wxPyBeginAllowThreads();
33317 result = (bool)(arg1)->Validate();
33318 wxPyEndAllowThreads(__tstate);
33319 if (PyErr_Occurred()) SWIG_fail;
33320 }
33321 {
33322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33323 }
33324 return resultobj;
33325 fail:
33326 return NULL;
33327 }
33328
33329
33330 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33331 PyObject *resultobj = 0;
33332 wxWindow *arg1 = (wxWindow *) 0 ;
33333 bool result;
33334 void *argp1 = 0 ;
33335 int res1 = 0 ;
33336 PyObject *swig_obj[1] ;
33337
33338 if (!args) SWIG_fail;
33339 swig_obj[0] = args;
33340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33341 if (!SWIG_IsOK(res1)) {
33342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33343 }
33344 arg1 = reinterpret_cast< wxWindow * >(argp1);
33345 {
33346 PyThreadState* __tstate = wxPyBeginAllowThreads();
33347 result = (bool)(arg1)->TransferDataToWindow();
33348 wxPyEndAllowThreads(__tstate);
33349 if (PyErr_Occurred()) SWIG_fail;
33350 }
33351 {
33352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33353 }
33354 return resultobj;
33355 fail:
33356 return NULL;
33357 }
33358
33359
33360 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33361 PyObject *resultobj = 0;
33362 wxWindow *arg1 = (wxWindow *) 0 ;
33363 bool result;
33364 void *argp1 = 0 ;
33365 int res1 = 0 ;
33366 PyObject *swig_obj[1] ;
33367
33368 if (!args) SWIG_fail;
33369 swig_obj[0] = args;
33370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33371 if (!SWIG_IsOK(res1)) {
33372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33373 }
33374 arg1 = reinterpret_cast< wxWindow * >(argp1);
33375 {
33376 PyThreadState* __tstate = wxPyBeginAllowThreads();
33377 result = (bool)(arg1)->TransferDataFromWindow();
33378 wxPyEndAllowThreads(__tstate);
33379 if (PyErr_Occurred()) SWIG_fail;
33380 }
33381 {
33382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33383 }
33384 return resultobj;
33385 fail:
33386 return NULL;
33387 }
33388
33389
33390 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33391 PyObject *resultobj = 0;
33392 wxWindow *arg1 = (wxWindow *) 0 ;
33393 void *argp1 = 0 ;
33394 int res1 = 0 ;
33395 PyObject *swig_obj[1] ;
33396
33397 if (!args) SWIG_fail;
33398 swig_obj[0] = args;
33399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33400 if (!SWIG_IsOK(res1)) {
33401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33402 }
33403 arg1 = reinterpret_cast< wxWindow * >(argp1);
33404 {
33405 PyThreadState* __tstate = wxPyBeginAllowThreads();
33406 (arg1)->InitDialog();
33407 wxPyEndAllowThreads(__tstate);
33408 if (PyErr_Occurred()) SWIG_fail;
33409 }
33410 resultobj = SWIG_Py_Void();
33411 return resultobj;
33412 fail:
33413 return NULL;
33414 }
33415
33416
33417 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33418 PyObject *resultobj = 0;
33419 wxWindow *arg1 = (wxWindow *) 0 ;
33420 wxAcceleratorTable *arg2 = 0 ;
33421 void *argp1 = 0 ;
33422 int res1 = 0 ;
33423 void *argp2 = 0 ;
33424 int res2 = 0 ;
33425 PyObject * obj0 = 0 ;
33426 PyObject * obj1 = 0 ;
33427 char * kwnames[] = {
33428 (char *) "self",(char *) "accel", NULL
33429 };
33430
33431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33433 if (!SWIG_IsOK(res1)) {
33434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33435 }
33436 arg1 = reinterpret_cast< wxWindow * >(argp1);
33437 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33438 if (!SWIG_IsOK(res2)) {
33439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33440 }
33441 if (!argp2) {
33442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33443 }
33444 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33445 {
33446 PyThreadState* __tstate = wxPyBeginAllowThreads();
33447 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33448 wxPyEndAllowThreads(__tstate);
33449 if (PyErr_Occurred()) SWIG_fail;
33450 }
33451 resultobj = SWIG_Py_Void();
33452 return resultobj;
33453 fail:
33454 return NULL;
33455 }
33456
33457
33458 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33459 PyObject *resultobj = 0;
33460 wxWindow *arg1 = (wxWindow *) 0 ;
33461 wxAcceleratorTable *result = 0 ;
33462 void *argp1 = 0 ;
33463 int res1 = 0 ;
33464 PyObject *swig_obj[1] ;
33465
33466 if (!args) SWIG_fail;
33467 swig_obj[0] = args;
33468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33469 if (!SWIG_IsOK(res1)) {
33470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33471 }
33472 arg1 = reinterpret_cast< wxWindow * >(argp1);
33473 {
33474 PyThreadState* __tstate = wxPyBeginAllowThreads();
33475 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33476 wxPyEndAllowThreads(__tstate);
33477 if (PyErr_Occurred()) SWIG_fail;
33478 }
33479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33480 return resultobj;
33481 fail:
33482 return NULL;
33483 }
33484
33485
33486 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33487 PyObject *resultobj = 0;
33488 wxWindow *arg1 = (wxWindow *) 0 ;
33489 int arg2 ;
33490 int arg3 ;
33491 int arg4 ;
33492 bool result;
33493 void *argp1 = 0 ;
33494 int res1 = 0 ;
33495 int val2 ;
33496 int ecode2 = 0 ;
33497 int val3 ;
33498 int ecode3 = 0 ;
33499 int val4 ;
33500 int ecode4 = 0 ;
33501 PyObject * obj0 = 0 ;
33502 PyObject * obj1 = 0 ;
33503 PyObject * obj2 = 0 ;
33504 PyObject * obj3 = 0 ;
33505 char * kwnames[] = {
33506 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33507 };
33508
33509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33511 if (!SWIG_IsOK(res1)) {
33512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33513 }
33514 arg1 = reinterpret_cast< wxWindow * >(argp1);
33515 ecode2 = SWIG_AsVal_int(obj1, &val2);
33516 if (!SWIG_IsOK(ecode2)) {
33517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33518 }
33519 arg2 = static_cast< int >(val2);
33520 ecode3 = SWIG_AsVal_int(obj2, &val3);
33521 if (!SWIG_IsOK(ecode3)) {
33522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33523 }
33524 arg3 = static_cast< int >(val3);
33525 ecode4 = SWIG_AsVal_int(obj3, &val4);
33526 if (!SWIG_IsOK(ecode4)) {
33527 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33528 }
33529 arg4 = static_cast< int >(val4);
33530 {
33531 PyThreadState* __tstate = wxPyBeginAllowThreads();
33532 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33533 wxPyEndAllowThreads(__tstate);
33534 if (PyErr_Occurred()) SWIG_fail;
33535 }
33536 {
33537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33538 }
33539 return resultobj;
33540 fail:
33541 return NULL;
33542 }
33543
33544
33545 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33546 PyObject *resultobj = 0;
33547 wxWindow *arg1 = (wxWindow *) 0 ;
33548 int arg2 ;
33549 bool result;
33550 void *argp1 = 0 ;
33551 int res1 = 0 ;
33552 int val2 ;
33553 int ecode2 = 0 ;
33554 PyObject * obj0 = 0 ;
33555 PyObject * obj1 = 0 ;
33556 char * kwnames[] = {
33557 (char *) "self",(char *) "hotkeyId", NULL
33558 };
33559
33560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33562 if (!SWIG_IsOK(res1)) {
33563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33564 }
33565 arg1 = reinterpret_cast< wxWindow * >(argp1);
33566 ecode2 = SWIG_AsVal_int(obj1, &val2);
33567 if (!SWIG_IsOK(ecode2)) {
33568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33569 }
33570 arg2 = static_cast< int >(val2);
33571 {
33572 PyThreadState* __tstate = wxPyBeginAllowThreads();
33573 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33574 wxPyEndAllowThreads(__tstate);
33575 if (PyErr_Occurred()) SWIG_fail;
33576 }
33577 {
33578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33579 }
33580 return resultobj;
33581 fail:
33582 return NULL;
33583 }
33584
33585
33586 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33587 PyObject *resultobj = 0;
33588 wxWindow *arg1 = (wxWindow *) 0 ;
33589 wxPoint *arg2 = 0 ;
33590 wxPoint result;
33591 void *argp1 = 0 ;
33592 int res1 = 0 ;
33593 wxPoint temp2 ;
33594 PyObject * obj0 = 0 ;
33595 PyObject * obj1 = 0 ;
33596 char * kwnames[] = {
33597 (char *) "self",(char *) "pt", NULL
33598 };
33599
33600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33602 if (!SWIG_IsOK(res1)) {
33603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33604 }
33605 arg1 = reinterpret_cast< wxWindow * >(argp1);
33606 {
33607 arg2 = &temp2;
33608 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33609 }
33610 {
33611 PyThreadState* __tstate = wxPyBeginAllowThreads();
33612 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33613 wxPyEndAllowThreads(__tstate);
33614 if (PyErr_Occurred()) SWIG_fail;
33615 }
33616 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33617 return resultobj;
33618 fail:
33619 return NULL;
33620 }
33621
33622
33623 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33624 PyObject *resultobj = 0;
33625 wxWindow *arg1 = (wxWindow *) 0 ;
33626 wxSize *arg2 = 0 ;
33627 wxSize result;
33628 void *argp1 = 0 ;
33629 int res1 = 0 ;
33630 wxSize temp2 ;
33631 PyObject * obj0 = 0 ;
33632 PyObject * obj1 = 0 ;
33633 char * kwnames[] = {
33634 (char *) "self",(char *) "sz", NULL
33635 };
33636
33637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33639 if (!SWIG_IsOK(res1)) {
33640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33641 }
33642 arg1 = reinterpret_cast< wxWindow * >(argp1);
33643 {
33644 arg2 = &temp2;
33645 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33646 }
33647 {
33648 PyThreadState* __tstate = wxPyBeginAllowThreads();
33649 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33650 wxPyEndAllowThreads(__tstate);
33651 if (PyErr_Occurred()) SWIG_fail;
33652 }
33653 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33654 return resultobj;
33655 fail:
33656 return NULL;
33657 }
33658
33659
33660 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33661 PyObject *resultobj = 0;
33662 wxWindow *arg1 = (wxWindow *) 0 ;
33663 wxPoint *arg2 = 0 ;
33664 wxPoint result;
33665 void *argp1 = 0 ;
33666 int res1 = 0 ;
33667 wxPoint temp2 ;
33668 PyObject * obj0 = 0 ;
33669 PyObject * obj1 = 0 ;
33670 char * kwnames[] = {
33671 (char *) "self",(char *) "pt", NULL
33672 };
33673
33674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33676 if (!SWIG_IsOK(res1)) {
33677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33678 }
33679 arg1 = reinterpret_cast< wxWindow * >(argp1);
33680 {
33681 arg2 = &temp2;
33682 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33683 }
33684 {
33685 PyThreadState* __tstate = wxPyBeginAllowThreads();
33686 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33687 wxPyEndAllowThreads(__tstate);
33688 if (PyErr_Occurred()) SWIG_fail;
33689 }
33690 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33691 return resultobj;
33692 fail:
33693 return NULL;
33694 }
33695
33696
33697 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33698 PyObject *resultobj = 0;
33699 wxWindow *arg1 = (wxWindow *) 0 ;
33700 wxSize *arg2 = 0 ;
33701 wxSize result;
33702 void *argp1 = 0 ;
33703 int res1 = 0 ;
33704 wxSize temp2 ;
33705 PyObject * obj0 = 0 ;
33706 PyObject * obj1 = 0 ;
33707 char * kwnames[] = {
33708 (char *) "self",(char *) "sz", NULL
33709 };
33710
33711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33713 if (!SWIG_IsOK(res1)) {
33714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33715 }
33716 arg1 = reinterpret_cast< wxWindow * >(argp1);
33717 {
33718 arg2 = &temp2;
33719 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33720 }
33721 {
33722 PyThreadState* __tstate = wxPyBeginAllowThreads();
33723 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33724 wxPyEndAllowThreads(__tstate);
33725 if (PyErr_Occurred()) SWIG_fail;
33726 }
33727 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33728 return resultobj;
33729 fail:
33730 return NULL;
33731 }
33732
33733
33734 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33735 PyObject *resultobj = 0;
33736 wxWindow *arg1 = (wxWindow *) 0 ;
33737 wxPoint *arg2 = 0 ;
33738 wxPoint result;
33739 void *argp1 = 0 ;
33740 int res1 = 0 ;
33741 wxPoint temp2 ;
33742 PyObject * obj0 = 0 ;
33743 PyObject * obj1 = 0 ;
33744 char * kwnames[] = {
33745 (char *) "self",(char *) "pt", NULL
33746 };
33747
33748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33750 if (!SWIG_IsOK(res1)) {
33751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33752 }
33753 arg1 = reinterpret_cast< wxWindow * >(argp1);
33754 {
33755 arg2 = &temp2;
33756 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33757 }
33758 {
33759 PyThreadState* __tstate = wxPyBeginAllowThreads();
33760 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33761 wxPyEndAllowThreads(__tstate);
33762 if (PyErr_Occurred()) SWIG_fail;
33763 }
33764 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33765 return resultobj;
33766 fail:
33767 return NULL;
33768 }
33769
33770
33771 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33772 PyObject *resultobj = 0;
33773 wxWindow *arg1 = (wxWindow *) 0 ;
33774 wxSize *arg2 = 0 ;
33775 wxSize result;
33776 void *argp1 = 0 ;
33777 int res1 = 0 ;
33778 wxSize temp2 ;
33779 PyObject * obj0 = 0 ;
33780 PyObject * obj1 = 0 ;
33781 char * kwnames[] = {
33782 (char *) "self",(char *) "sz", NULL
33783 };
33784
33785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33787 if (!SWIG_IsOK(res1)) {
33788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33789 }
33790 arg1 = reinterpret_cast< wxWindow * >(argp1);
33791 {
33792 arg2 = &temp2;
33793 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33794 }
33795 {
33796 PyThreadState* __tstate = wxPyBeginAllowThreads();
33797 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33798 wxPyEndAllowThreads(__tstate);
33799 if (PyErr_Occurred()) SWIG_fail;
33800 }
33801 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33802 return resultobj;
33803 fail:
33804 return NULL;
33805 }
33806
33807
33808 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33809 PyObject *resultobj = 0;
33810 wxWindow *arg1 = (wxWindow *) 0 ;
33811 int arg2 ;
33812 int arg3 ;
33813 void *argp1 = 0 ;
33814 int res1 = 0 ;
33815 int val2 ;
33816 int ecode2 = 0 ;
33817 int val3 ;
33818 int ecode3 = 0 ;
33819 PyObject * obj0 = 0 ;
33820 PyObject * obj1 = 0 ;
33821 PyObject * obj2 = 0 ;
33822 char * kwnames[] = {
33823 (char *) "self",(char *) "x",(char *) "y", NULL
33824 };
33825
33826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33828 if (!SWIG_IsOK(res1)) {
33829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
33830 }
33831 arg1 = reinterpret_cast< wxWindow * >(argp1);
33832 ecode2 = SWIG_AsVal_int(obj1, &val2);
33833 if (!SWIG_IsOK(ecode2)) {
33834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
33835 }
33836 arg2 = static_cast< int >(val2);
33837 ecode3 = SWIG_AsVal_int(obj2, &val3);
33838 if (!SWIG_IsOK(ecode3)) {
33839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
33840 }
33841 arg3 = static_cast< int >(val3);
33842 {
33843 PyThreadState* __tstate = wxPyBeginAllowThreads();
33844 (arg1)->WarpPointer(arg2,arg3);
33845 wxPyEndAllowThreads(__tstate);
33846 if (PyErr_Occurred()) SWIG_fail;
33847 }
33848 resultobj = SWIG_Py_Void();
33849 return resultobj;
33850 fail:
33851 return NULL;
33852 }
33853
33854
33855 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33856 PyObject *resultobj = 0;
33857 wxWindow *arg1 = (wxWindow *) 0 ;
33858 void *argp1 = 0 ;
33859 int res1 = 0 ;
33860 PyObject *swig_obj[1] ;
33861
33862 if (!args) SWIG_fail;
33863 swig_obj[0] = args;
33864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33865 if (!SWIG_IsOK(res1)) {
33866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33867 }
33868 arg1 = reinterpret_cast< wxWindow * >(argp1);
33869 {
33870 PyThreadState* __tstate = wxPyBeginAllowThreads();
33871 (arg1)->CaptureMouse();
33872 wxPyEndAllowThreads(__tstate);
33873 if (PyErr_Occurred()) SWIG_fail;
33874 }
33875 resultobj = SWIG_Py_Void();
33876 return resultobj;
33877 fail:
33878 return NULL;
33879 }
33880
33881
33882 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33883 PyObject *resultobj = 0;
33884 wxWindow *arg1 = (wxWindow *) 0 ;
33885 void *argp1 = 0 ;
33886 int res1 = 0 ;
33887 PyObject *swig_obj[1] ;
33888
33889 if (!args) SWIG_fail;
33890 swig_obj[0] = args;
33891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33892 if (!SWIG_IsOK(res1)) {
33893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33894 }
33895 arg1 = reinterpret_cast< wxWindow * >(argp1);
33896 {
33897 PyThreadState* __tstate = wxPyBeginAllowThreads();
33898 (arg1)->ReleaseMouse();
33899 wxPyEndAllowThreads(__tstate);
33900 if (PyErr_Occurred()) SWIG_fail;
33901 }
33902 resultobj = SWIG_Py_Void();
33903 return resultobj;
33904 fail:
33905 return NULL;
33906 }
33907
33908
33909 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33910 PyObject *resultobj = 0;
33911 wxWindow *result = 0 ;
33912
33913 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
33914 {
33915 if (!wxPyCheckForApp()) SWIG_fail;
33916 PyThreadState* __tstate = wxPyBeginAllowThreads();
33917 result = (wxWindow *)wxWindow::GetCapture();
33918 wxPyEndAllowThreads(__tstate);
33919 if (PyErr_Occurred()) SWIG_fail;
33920 }
33921 {
33922 resultobj = wxPyMake_wxObject(result, 0);
33923 }
33924 return resultobj;
33925 fail:
33926 return NULL;
33927 }
33928
33929
33930 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33931 PyObject *resultobj = 0;
33932 wxWindow *arg1 = (wxWindow *) 0 ;
33933 bool result;
33934 void *argp1 = 0 ;
33935 int res1 = 0 ;
33936 PyObject *swig_obj[1] ;
33937
33938 if (!args) SWIG_fail;
33939 swig_obj[0] = args;
33940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33941 if (!SWIG_IsOK(res1)) {
33942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
33943 }
33944 arg1 = reinterpret_cast< wxWindow * >(argp1);
33945 {
33946 PyThreadState* __tstate = wxPyBeginAllowThreads();
33947 result = (bool)((wxWindow const *)arg1)->HasCapture();
33948 wxPyEndAllowThreads(__tstate);
33949 if (PyErr_Occurred()) SWIG_fail;
33950 }
33951 {
33952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33953 }
33954 return resultobj;
33955 fail:
33956 return NULL;
33957 }
33958
33959
33960 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33961 PyObject *resultobj = 0;
33962 wxWindow *arg1 = (wxWindow *) 0 ;
33963 bool arg2 = (bool) true ;
33964 wxRect *arg3 = (wxRect *) NULL ;
33965 void *argp1 = 0 ;
33966 int res1 = 0 ;
33967 bool val2 ;
33968 int ecode2 = 0 ;
33969 void *argp3 = 0 ;
33970 int res3 = 0 ;
33971 PyObject * obj0 = 0 ;
33972 PyObject * obj1 = 0 ;
33973 PyObject * obj2 = 0 ;
33974 char * kwnames[] = {
33975 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
33976 };
33977
33978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33980 if (!SWIG_IsOK(res1)) {
33981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
33982 }
33983 arg1 = reinterpret_cast< wxWindow * >(argp1);
33984 if (obj1) {
33985 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33986 if (!SWIG_IsOK(ecode2)) {
33987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
33988 }
33989 arg2 = static_cast< bool >(val2);
33990 }
33991 if (obj2) {
33992 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
33993 if (!SWIG_IsOK(res3)) {
33994 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
33995 }
33996 arg3 = reinterpret_cast< wxRect * >(argp3);
33997 }
33998 {
33999 PyThreadState* __tstate = wxPyBeginAllowThreads();
34000 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34001 wxPyEndAllowThreads(__tstate);
34002 if (PyErr_Occurred()) SWIG_fail;
34003 }
34004 resultobj = SWIG_Py_Void();
34005 return resultobj;
34006 fail:
34007 return NULL;
34008 }
34009
34010
34011 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34012 PyObject *resultobj = 0;
34013 wxWindow *arg1 = (wxWindow *) 0 ;
34014 wxRect *arg2 = 0 ;
34015 bool arg3 = (bool) true ;
34016 void *argp1 = 0 ;
34017 int res1 = 0 ;
34018 wxRect temp2 ;
34019 bool val3 ;
34020 int ecode3 = 0 ;
34021 PyObject * obj0 = 0 ;
34022 PyObject * obj1 = 0 ;
34023 PyObject * obj2 = 0 ;
34024 char * kwnames[] = {
34025 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34026 };
34027
34028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) 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_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34032 }
34033 arg1 = reinterpret_cast< wxWindow * >(argp1);
34034 {
34035 arg2 = &temp2;
34036 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34037 }
34038 if (obj2) {
34039 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34040 if (!SWIG_IsOK(ecode3)) {
34041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34042 }
34043 arg3 = static_cast< bool >(val3);
34044 }
34045 {
34046 PyThreadState* __tstate = wxPyBeginAllowThreads();
34047 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34048 wxPyEndAllowThreads(__tstate);
34049 if (PyErr_Occurred()) SWIG_fail;
34050 }
34051 resultobj = SWIG_Py_Void();
34052 return resultobj;
34053 fail:
34054 return NULL;
34055 }
34056
34057
34058 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34059 PyObject *resultobj = 0;
34060 wxWindow *arg1 = (wxWindow *) 0 ;
34061 void *argp1 = 0 ;
34062 int res1 = 0 ;
34063 PyObject *swig_obj[1] ;
34064
34065 if (!args) SWIG_fail;
34066 swig_obj[0] = args;
34067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34068 if (!SWIG_IsOK(res1)) {
34069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34070 }
34071 arg1 = reinterpret_cast< wxWindow * >(argp1);
34072 {
34073 PyThreadState* __tstate = wxPyBeginAllowThreads();
34074 (arg1)->Update();
34075 wxPyEndAllowThreads(__tstate);
34076 if (PyErr_Occurred()) SWIG_fail;
34077 }
34078 resultobj = SWIG_Py_Void();
34079 return resultobj;
34080 fail:
34081 return NULL;
34082 }
34083
34084
34085 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34086 PyObject *resultobj = 0;
34087 wxWindow *arg1 = (wxWindow *) 0 ;
34088 void *argp1 = 0 ;
34089 int res1 = 0 ;
34090 PyObject *swig_obj[1] ;
34091
34092 if (!args) SWIG_fail;
34093 swig_obj[0] = args;
34094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34095 if (!SWIG_IsOK(res1)) {
34096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34097 }
34098 arg1 = reinterpret_cast< wxWindow * >(argp1);
34099 {
34100 PyThreadState* __tstate = wxPyBeginAllowThreads();
34101 (arg1)->ClearBackground();
34102 wxPyEndAllowThreads(__tstate);
34103 if (PyErr_Occurred()) SWIG_fail;
34104 }
34105 resultobj = SWIG_Py_Void();
34106 return resultobj;
34107 fail:
34108 return NULL;
34109 }
34110
34111
34112 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34113 PyObject *resultobj = 0;
34114 wxWindow *arg1 = (wxWindow *) 0 ;
34115 void *argp1 = 0 ;
34116 int res1 = 0 ;
34117 PyObject *swig_obj[1] ;
34118
34119 if (!args) SWIG_fail;
34120 swig_obj[0] = args;
34121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34122 if (!SWIG_IsOK(res1)) {
34123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34124 }
34125 arg1 = reinterpret_cast< wxWindow * >(argp1);
34126 {
34127 PyThreadState* __tstate = wxPyBeginAllowThreads();
34128 (arg1)->Freeze();
34129 wxPyEndAllowThreads(__tstate);
34130 if (PyErr_Occurred()) SWIG_fail;
34131 }
34132 resultobj = SWIG_Py_Void();
34133 return resultobj;
34134 fail:
34135 return NULL;
34136 }
34137
34138
34139 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34140 PyObject *resultobj = 0;
34141 wxWindow *arg1 = (wxWindow *) 0 ;
34142 void *argp1 = 0 ;
34143 int res1 = 0 ;
34144 PyObject *swig_obj[1] ;
34145
34146 if (!args) SWIG_fail;
34147 swig_obj[0] = args;
34148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34149 if (!SWIG_IsOK(res1)) {
34150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34151 }
34152 arg1 = reinterpret_cast< wxWindow * >(argp1);
34153 {
34154 PyThreadState* __tstate = wxPyBeginAllowThreads();
34155 (arg1)->Thaw();
34156 wxPyEndAllowThreads(__tstate);
34157 if (PyErr_Occurred()) SWIG_fail;
34158 }
34159 resultobj = SWIG_Py_Void();
34160 return resultobj;
34161 fail:
34162 return NULL;
34163 }
34164
34165
34166 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34167 PyObject *resultobj = 0;
34168 wxWindow *arg1 = (wxWindow *) 0 ;
34169 wxDC *arg2 = 0 ;
34170 void *argp1 = 0 ;
34171 int res1 = 0 ;
34172 void *argp2 = 0 ;
34173 int res2 = 0 ;
34174 PyObject * obj0 = 0 ;
34175 PyObject * obj1 = 0 ;
34176 char * kwnames[] = {
34177 (char *) "self",(char *) "dc", NULL
34178 };
34179
34180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34182 if (!SWIG_IsOK(res1)) {
34183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34184 }
34185 arg1 = reinterpret_cast< wxWindow * >(argp1);
34186 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34187 if (!SWIG_IsOK(res2)) {
34188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34189 }
34190 if (!argp2) {
34191 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34192 }
34193 arg2 = reinterpret_cast< wxDC * >(argp2);
34194 {
34195 PyThreadState* __tstate = wxPyBeginAllowThreads();
34196 (arg1)->PrepareDC(*arg2);
34197 wxPyEndAllowThreads(__tstate);
34198 if (PyErr_Occurred()) SWIG_fail;
34199 }
34200 resultobj = SWIG_Py_Void();
34201 return resultobj;
34202 fail:
34203 return NULL;
34204 }
34205
34206
34207 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34208 PyObject *resultobj = 0;
34209 wxWindow *arg1 = (wxWindow *) 0 ;
34210 wxRegion *result = 0 ;
34211 void *argp1 = 0 ;
34212 int res1 = 0 ;
34213 PyObject *swig_obj[1] ;
34214
34215 if (!args) SWIG_fail;
34216 swig_obj[0] = args;
34217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34218 if (!SWIG_IsOK(res1)) {
34219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34220 }
34221 arg1 = reinterpret_cast< wxWindow * >(argp1);
34222 {
34223 PyThreadState* __tstate = wxPyBeginAllowThreads();
34224 {
34225 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34226 result = (wxRegion *) &_result_ref;
34227 }
34228 wxPyEndAllowThreads(__tstate);
34229 if (PyErr_Occurred()) SWIG_fail;
34230 }
34231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34232 return resultobj;
34233 fail:
34234 return NULL;
34235 }
34236
34237
34238 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34239 PyObject *resultobj = 0;
34240 wxWindow *arg1 = (wxWindow *) 0 ;
34241 wxRect result;
34242 void *argp1 = 0 ;
34243 int res1 = 0 ;
34244 PyObject *swig_obj[1] ;
34245
34246 if (!args) SWIG_fail;
34247 swig_obj[0] = args;
34248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34249 if (!SWIG_IsOK(res1)) {
34250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34251 }
34252 arg1 = reinterpret_cast< wxWindow * >(argp1);
34253 {
34254 PyThreadState* __tstate = wxPyBeginAllowThreads();
34255 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34256 wxPyEndAllowThreads(__tstate);
34257 if (PyErr_Occurred()) SWIG_fail;
34258 }
34259 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34260 return resultobj;
34261 fail:
34262 return NULL;
34263 }
34264
34265
34266 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34267 PyObject *resultobj = 0;
34268 wxWindow *arg1 = (wxWindow *) 0 ;
34269 int arg2 ;
34270 int arg3 ;
34271 int arg4 = (int) 1 ;
34272 int arg5 = (int) 1 ;
34273 bool result;
34274 void *argp1 = 0 ;
34275 int res1 = 0 ;
34276 int val2 ;
34277 int ecode2 = 0 ;
34278 int val3 ;
34279 int ecode3 = 0 ;
34280 int val4 ;
34281 int ecode4 = 0 ;
34282 int val5 ;
34283 int ecode5 = 0 ;
34284 PyObject * obj0 = 0 ;
34285 PyObject * obj1 = 0 ;
34286 PyObject * obj2 = 0 ;
34287 PyObject * obj3 = 0 ;
34288 PyObject * obj4 = 0 ;
34289 char * kwnames[] = {
34290 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34291 };
34292
34293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34295 if (!SWIG_IsOK(res1)) {
34296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34297 }
34298 arg1 = reinterpret_cast< wxWindow * >(argp1);
34299 ecode2 = SWIG_AsVal_int(obj1, &val2);
34300 if (!SWIG_IsOK(ecode2)) {
34301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34302 }
34303 arg2 = static_cast< int >(val2);
34304 ecode3 = SWIG_AsVal_int(obj2, &val3);
34305 if (!SWIG_IsOK(ecode3)) {
34306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34307 }
34308 arg3 = static_cast< int >(val3);
34309 if (obj3) {
34310 ecode4 = SWIG_AsVal_int(obj3, &val4);
34311 if (!SWIG_IsOK(ecode4)) {
34312 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34313 }
34314 arg4 = static_cast< int >(val4);
34315 }
34316 if (obj4) {
34317 ecode5 = SWIG_AsVal_int(obj4, &val5);
34318 if (!SWIG_IsOK(ecode5)) {
34319 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34320 }
34321 arg5 = static_cast< int >(val5);
34322 }
34323 {
34324 PyThreadState* __tstate = wxPyBeginAllowThreads();
34325 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34326 wxPyEndAllowThreads(__tstate);
34327 if (PyErr_Occurred()) SWIG_fail;
34328 }
34329 {
34330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34331 }
34332 return resultobj;
34333 fail:
34334 return NULL;
34335 }
34336
34337
34338 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34339 PyObject *resultobj = 0;
34340 wxWindow *arg1 = (wxWindow *) 0 ;
34341 wxPoint *arg2 = 0 ;
34342 bool result;
34343 void *argp1 = 0 ;
34344 int res1 = 0 ;
34345 wxPoint temp2 ;
34346 PyObject * obj0 = 0 ;
34347 PyObject * obj1 = 0 ;
34348 char * kwnames[] = {
34349 (char *) "self",(char *) "pt", NULL
34350 };
34351
34352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34354 if (!SWIG_IsOK(res1)) {
34355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34356 }
34357 arg1 = reinterpret_cast< wxWindow * >(argp1);
34358 {
34359 arg2 = &temp2;
34360 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34361 }
34362 {
34363 PyThreadState* __tstate = wxPyBeginAllowThreads();
34364 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34365 wxPyEndAllowThreads(__tstate);
34366 if (PyErr_Occurred()) SWIG_fail;
34367 }
34368 {
34369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34370 }
34371 return resultobj;
34372 fail:
34373 return NULL;
34374 }
34375
34376
34377 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34378 PyObject *resultobj = 0;
34379 wxWindow *arg1 = (wxWindow *) 0 ;
34380 wxRect *arg2 = 0 ;
34381 bool result;
34382 void *argp1 = 0 ;
34383 int res1 = 0 ;
34384 wxRect temp2 ;
34385 PyObject * obj0 = 0 ;
34386 PyObject * obj1 = 0 ;
34387 char * kwnames[] = {
34388 (char *) "self",(char *) "rect", NULL
34389 };
34390
34391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34393 if (!SWIG_IsOK(res1)) {
34394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34395 }
34396 arg1 = reinterpret_cast< wxWindow * >(argp1);
34397 {
34398 arg2 = &temp2;
34399 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34400 }
34401 {
34402 PyThreadState* __tstate = wxPyBeginAllowThreads();
34403 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34404 wxPyEndAllowThreads(__tstate);
34405 if (PyErr_Occurred()) SWIG_fail;
34406 }
34407 {
34408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34409 }
34410 return resultobj;
34411 fail:
34412 return NULL;
34413 }
34414
34415
34416 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34417 PyObject *resultobj = 0;
34418 wxWindow *arg1 = (wxWindow *) 0 ;
34419 SwigValueWrapper<wxVisualAttributes > result;
34420 void *argp1 = 0 ;
34421 int res1 = 0 ;
34422 PyObject *swig_obj[1] ;
34423
34424 if (!args) SWIG_fail;
34425 swig_obj[0] = args;
34426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34427 if (!SWIG_IsOK(res1)) {
34428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34429 }
34430 arg1 = reinterpret_cast< wxWindow * >(argp1);
34431 {
34432 PyThreadState* __tstate = wxPyBeginAllowThreads();
34433 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34438 return resultobj;
34439 fail:
34440 return NULL;
34441 }
34442
34443
34444 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34445 PyObject *resultobj = 0;
34446 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34447 SwigValueWrapper<wxVisualAttributes > result;
34448 int val1 ;
34449 int ecode1 = 0 ;
34450 PyObject * obj0 = 0 ;
34451 char * kwnames[] = {
34452 (char *) "variant", NULL
34453 };
34454
34455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34456 if (obj0) {
34457 ecode1 = SWIG_AsVal_int(obj0, &val1);
34458 if (!SWIG_IsOK(ecode1)) {
34459 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34460 }
34461 arg1 = static_cast< wxWindowVariant >(val1);
34462 }
34463 {
34464 if (!wxPyCheckForApp()) SWIG_fail;
34465 PyThreadState* __tstate = wxPyBeginAllowThreads();
34466 result = wxWindow::GetClassDefaultAttributes(arg1);
34467 wxPyEndAllowThreads(__tstate);
34468 if (PyErr_Occurred()) SWIG_fail;
34469 }
34470 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34471 return resultobj;
34472 fail:
34473 return NULL;
34474 }
34475
34476
34477 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34478 PyObject *resultobj = 0;
34479 wxWindow *arg1 = (wxWindow *) 0 ;
34480 wxColour *arg2 = 0 ;
34481 bool result;
34482 void *argp1 = 0 ;
34483 int res1 = 0 ;
34484 wxColour temp2 ;
34485 PyObject * obj0 = 0 ;
34486 PyObject * obj1 = 0 ;
34487 char * kwnames[] = {
34488 (char *) "self",(char *) "colour", NULL
34489 };
34490
34491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34493 if (!SWIG_IsOK(res1)) {
34494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34495 }
34496 arg1 = reinterpret_cast< wxWindow * >(argp1);
34497 {
34498 arg2 = &temp2;
34499 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34500 }
34501 {
34502 PyThreadState* __tstate = wxPyBeginAllowThreads();
34503 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34504 wxPyEndAllowThreads(__tstate);
34505 if (PyErr_Occurred()) SWIG_fail;
34506 }
34507 {
34508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34509 }
34510 return resultobj;
34511 fail:
34512 return NULL;
34513 }
34514
34515
34516 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34517 PyObject *resultobj = 0;
34518 wxWindow *arg1 = (wxWindow *) 0 ;
34519 wxColour *arg2 = 0 ;
34520 void *argp1 = 0 ;
34521 int res1 = 0 ;
34522 wxColour temp2 ;
34523 PyObject * obj0 = 0 ;
34524 PyObject * obj1 = 0 ;
34525 char * kwnames[] = {
34526 (char *) "self",(char *) "colour", NULL
34527 };
34528
34529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34531 if (!SWIG_IsOK(res1)) {
34532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34533 }
34534 arg1 = reinterpret_cast< wxWindow * >(argp1);
34535 {
34536 arg2 = &temp2;
34537 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34538 }
34539 {
34540 PyThreadState* __tstate = wxPyBeginAllowThreads();
34541 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34542 wxPyEndAllowThreads(__tstate);
34543 if (PyErr_Occurred()) SWIG_fail;
34544 }
34545 resultobj = SWIG_Py_Void();
34546 return resultobj;
34547 fail:
34548 return NULL;
34549 }
34550
34551
34552 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34553 PyObject *resultobj = 0;
34554 wxWindow *arg1 = (wxWindow *) 0 ;
34555 wxColour *arg2 = 0 ;
34556 bool result;
34557 void *argp1 = 0 ;
34558 int res1 = 0 ;
34559 wxColour temp2 ;
34560 PyObject * obj0 = 0 ;
34561 PyObject * obj1 = 0 ;
34562 char * kwnames[] = {
34563 (char *) "self",(char *) "colour", NULL
34564 };
34565
34566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34568 if (!SWIG_IsOK(res1)) {
34569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34570 }
34571 arg1 = reinterpret_cast< wxWindow * >(argp1);
34572 {
34573 arg2 = &temp2;
34574 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34575 }
34576 {
34577 PyThreadState* __tstate = wxPyBeginAllowThreads();
34578 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34579 wxPyEndAllowThreads(__tstate);
34580 if (PyErr_Occurred()) SWIG_fail;
34581 }
34582 {
34583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34584 }
34585 return resultobj;
34586 fail:
34587 return NULL;
34588 }
34589
34590
34591 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34592 PyObject *resultobj = 0;
34593 wxWindow *arg1 = (wxWindow *) 0 ;
34594 wxColour *arg2 = 0 ;
34595 void *argp1 = 0 ;
34596 int res1 = 0 ;
34597 wxColour temp2 ;
34598 PyObject * obj0 = 0 ;
34599 PyObject * obj1 = 0 ;
34600 char * kwnames[] = {
34601 (char *) "self",(char *) "colour", NULL
34602 };
34603
34604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34606 if (!SWIG_IsOK(res1)) {
34607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34608 }
34609 arg1 = reinterpret_cast< wxWindow * >(argp1);
34610 {
34611 arg2 = &temp2;
34612 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34613 }
34614 {
34615 PyThreadState* __tstate = wxPyBeginAllowThreads();
34616 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34617 wxPyEndAllowThreads(__tstate);
34618 if (PyErr_Occurred()) SWIG_fail;
34619 }
34620 resultobj = SWIG_Py_Void();
34621 return resultobj;
34622 fail:
34623 return NULL;
34624 }
34625
34626
34627 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34628 PyObject *resultobj = 0;
34629 wxWindow *arg1 = (wxWindow *) 0 ;
34630 wxColour result;
34631 void *argp1 = 0 ;
34632 int res1 = 0 ;
34633 PyObject *swig_obj[1] ;
34634
34635 if (!args) SWIG_fail;
34636 swig_obj[0] = args;
34637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34638 if (!SWIG_IsOK(res1)) {
34639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34640 }
34641 arg1 = reinterpret_cast< wxWindow * >(argp1);
34642 {
34643 PyThreadState* __tstate = wxPyBeginAllowThreads();
34644 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34645 wxPyEndAllowThreads(__tstate);
34646 if (PyErr_Occurred()) SWIG_fail;
34647 }
34648 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34649 return resultobj;
34650 fail:
34651 return NULL;
34652 }
34653
34654
34655 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34656 PyObject *resultobj = 0;
34657 wxWindow *arg1 = (wxWindow *) 0 ;
34658 wxColour result;
34659 void *argp1 = 0 ;
34660 int res1 = 0 ;
34661 PyObject *swig_obj[1] ;
34662
34663 if (!args) SWIG_fail;
34664 swig_obj[0] = args;
34665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34666 if (!SWIG_IsOK(res1)) {
34667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34668 }
34669 arg1 = reinterpret_cast< wxWindow * >(argp1);
34670 {
34671 PyThreadState* __tstate = wxPyBeginAllowThreads();
34672 result = ((wxWindow const *)arg1)->GetForegroundColour();
34673 wxPyEndAllowThreads(__tstate);
34674 if (PyErr_Occurred()) SWIG_fail;
34675 }
34676 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34677 return resultobj;
34678 fail:
34679 return NULL;
34680 }
34681
34682
34683 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34684 PyObject *resultobj = 0;
34685 wxWindow *arg1 = (wxWindow *) 0 ;
34686 bool result;
34687 void *argp1 = 0 ;
34688 int res1 = 0 ;
34689 PyObject *swig_obj[1] ;
34690
34691 if (!args) SWIG_fail;
34692 swig_obj[0] = args;
34693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34694 if (!SWIG_IsOK(res1)) {
34695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34696 }
34697 arg1 = reinterpret_cast< wxWindow * >(argp1);
34698 {
34699 PyThreadState* __tstate = wxPyBeginAllowThreads();
34700 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34701 wxPyEndAllowThreads(__tstate);
34702 if (PyErr_Occurred()) SWIG_fail;
34703 }
34704 {
34705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34706 }
34707 return resultobj;
34708 fail:
34709 return NULL;
34710 }
34711
34712
34713 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34714 PyObject *resultobj = 0;
34715 wxWindow *arg1 = (wxWindow *) 0 ;
34716 bool result;
34717 void *argp1 = 0 ;
34718 int res1 = 0 ;
34719 PyObject *swig_obj[1] ;
34720
34721 if (!args) SWIG_fail;
34722 swig_obj[0] = args;
34723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34724 if (!SWIG_IsOK(res1)) {
34725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34726 }
34727 arg1 = reinterpret_cast< wxWindow * >(argp1);
34728 {
34729 PyThreadState* __tstate = wxPyBeginAllowThreads();
34730 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34731 wxPyEndAllowThreads(__tstate);
34732 if (PyErr_Occurred()) SWIG_fail;
34733 }
34734 {
34735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34736 }
34737 return resultobj;
34738 fail:
34739 return NULL;
34740 }
34741
34742
34743 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34744 PyObject *resultobj = 0;
34745 wxWindow *arg1 = (wxWindow *) 0 ;
34746 wxBackgroundStyle arg2 ;
34747 bool result;
34748 void *argp1 = 0 ;
34749 int res1 = 0 ;
34750 int val2 ;
34751 int ecode2 = 0 ;
34752 PyObject * obj0 = 0 ;
34753 PyObject * obj1 = 0 ;
34754 char * kwnames[] = {
34755 (char *) "self",(char *) "style", NULL
34756 };
34757
34758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34760 if (!SWIG_IsOK(res1)) {
34761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34762 }
34763 arg1 = reinterpret_cast< wxWindow * >(argp1);
34764 ecode2 = SWIG_AsVal_int(obj1, &val2);
34765 if (!SWIG_IsOK(ecode2)) {
34766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34767 }
34768 arg2 = static_cast< wxBackgroundStyle >(val2);
34769 {
34770 PyThreadState* __tstate = wxPyBeginAllowThreads();
34771 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34772 wxPyEndAllowThreads(__tstate);
34773 if (PyErr_Occurred()) SWIG_fail;
34774 }
34775 {
34776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34777 }
34778 return resultobj;
34779 fail:
34780 return NULL;
34781 }
34782
34783
34784 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34785 PyObject *resultobj = 0;
34786 wxWindow *arg1 = (wxWindow *) 0 ;
34787 wxBackgroundStyle result;
34788 void *argp1 = 0 ;
34789 int res1 = 0 ;
34790 PyObject *swig_obj[1] ;
34791
34792 if (!args) SWIG_fail;
34793 swig_obj[0] = args;
34794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34795 if (!SWIG_IsOK(res1)) {
34796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34797 }
34798 arg1 = reinterpret_cast< wxWindow * >(argp1);
34799 {
34800 PyThreadState* __tstate = wxPyBeginAllowThreads();
34801 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34802 wxPyEndAllowThreads(__tstate);
34803 if (PyErr_Occurred()) SWIG_fail;
34804 }
34805 resultobj = SWIG_From_int(static_cast< int >(result));
34806 return resultobj;
34807 fail:
34808 return NULL;
34809 }
34810
34811
34812 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34813 PyObject *resultobj = 0;
34814 wxWindow *arg1 = (wxWindow *) 0 ;
34815 bool result;
34816 void *argp1 = 0 ;
34817 int res1 = 0 ;
34818 PyObject *swig_obj[1] ;
34819
34820 if (!args) SWIG_fail;
34821 swig_obj[0] = args;
34822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34823 if (!SWIG_IsOK(res1)) {
34824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34825 }
34826 arg1 = reinterpret_cast< wxWindow * >(argp1);
34827 {
34828 PyThreadState* __tstate = wxPyBeginAllowThreads();
34829 result = (bool)(arg1)->HasTransparentBackground();
34830 wxPyEndAllowThreads(__tstate);
34831 if (PyErr_Occurred()) SWIG_fail;
34832 }
34833 {
34834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34835 }
34836 return resultobj;
34837 fail:
34838 return NULL;
34839 }
34840
34841
34842 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34843 PyObject *resultobj = 0;
34844 wxWindow *arg1 = (wxWindow *) 0 ;
34845 wxCursor *arg2 = 0 ;
34846 bool result;
34847 void *argp1 = 0 ;
34848 int res1 = 0 ;
34849 void *argp2 = 0 ;
34850 int res2 = 0 ;
34851 PyObject * obj0 = 0 ;
34852 PyObject * obj1 = 0 ;
34853 char * kwnames[] = {
34854 (char *) "self",(char *) "cursor", NULL
34855 };
34856
34857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
34858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34859 if (!SWIG_IsOK(res1)) {
34860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
34861 }
34862 arg1 = reinterpret_cast< wxWindow * >(argp1);
34863 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
34864 if (!SWIG_IsOK(res2)) {
34865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34866 }
34867 if (!argp2) {
34868 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34869 }
34870 arg2 = reinterpret_cast< wxCursor * >(argp2);
34871 {
34872 PyThreadState* __tstate = wxPyBeginAllowThreads();
34873 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
34874 wxPyEndAllowThreads(__tstate);
34875 if (PyErr_Occurred()) SWIG_fail;
34876 }
34877 {
34878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34879 }
34880 return resultobj;
34881 fail:
34882 return NULL;
34883 }
34884
34885
34886 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34887 PyObject *resultobj = 0;
34888 wxWindow *arg1 = (wxWindow *) 0 ;
34889 wxCursor result;
34890 void *argp1 = 0 ;
34891 int res1 = 0 ;
34892 PyObject *swig_obj[1] ;
34893
34894 if (!args) SWIG_fail;
34895 swig_obj[0] = args;
34896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34897 if (!SWIG_IsOK(res1)) {
34898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
34899 }
34900 arg1 = reinterpret_cast< wxWindow * >(argp1);
34901 {
34902 PyThreadState* __tstate = wxPyBeginAllowThreads();
34903 result = (arg1)->GetCursor();
34904 wxPyEndAllowThreads(__tstate);
34905 if (PyErr_Occurred()) SWIG_fail;
34906 }
34907 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
34908 return resultobj;
34909 fail:
34910 return NULL;
34911 }
34912
34913
34914 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34915 PyObject *resultobj = 0;
34916 wxWindow *arg1 = (wxWindow *) 0 ;
34917 wxFont *arg2 = 0 ;
34918 bool result;
34919 void *argp1 = 0 ;
34920 int res1 = 0 ;
34921 void *argp2 = 0 ;
34922 int res2 = 0 ;
34923 PyObject * obj0 = 0 ;
34924 PyObject * obj1 = 0 ;
34925 char * kwnames[] = {
34926 (char *) "self",(char *) "font", NULL
34927 };
34928
34929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
34930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34931 if (!SWIG_IsOK(res1)) {
34932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
34933 }
34934 arg1 = reinterpret_cast< wxWindow * >(argp1);
34935 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
34936 if (!SWIG_IsOK(res2)) {
34937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
34938 }
34939 if (!argp2) {
34940 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
34941 }
34942 arg2 = reinterpret_cast< wxFont * >(argp2);
34943 {
34944 PyThreadState* __tstate = wxPyBeginAllowThreads();
34945 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
34946 wxPyEndAllowThreads(__tstate);
34947 if (PyErr_Occurred()) SWIG_fail;
34948 }
34949 {
34950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34951 }
34952 return resultobj;
34953 fail:
34954 return NULL;
34955 }
34956
34957
34958 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34959 PyObject *resultobj = 0;
34960 wxWindow *arg1 = (wxWindow *) 0 ;
34961 wxFont *arg2 = 0 ;
34962 void *argp1 = 0 ;
34963 int res1 = 0 ;
34964 void *argp2 = 0 ;
34965 int res2 = 0 ;
34966 PyObject * obj0 = 0 ;
34967 PyObject * obj1 = 0 ;
34968 char * kwnames[] = {
34969 (char *) "self",(char *) "font", NULL
34970 };
34971
34972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
34973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34974 if (!SWIG_IsOK(res1)) {
34975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
34976 }
34977 arg1 = reinterpret_cast< wxWindow * >(argp1);
34978 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
34979 if (!SWIG_IsOK(res2)) {
34980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
34981 }
34982 if (!argp2) {
34983 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
34984 }
34985 arg2 = reinterpret_cast< wxFont * >(argp2);
34986 {
34987 PyThreadState* __tstate = wxPyBeginAllowThreads();
34988 (arg1)->SetOwnFont((wxFont const &)*arg2);
34989 wxPyEndAllowThreads(__tstate);
34990 if (PyErr_Occurred()) SWIG_fail;
34991 }
34992 resultobj = SWIG_Py_Void();
34993 return resultobj;
34994 fail:
34995 return NULL;
34996 }
34997
34998
34999 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35000 PyObject *resultobj = 0;
35001 wxWindow *arg1 = (wxWindow *) 0 ;
35002 wxFont result;
35003 void *argp1 = 0 ;
35004 int res1 = 0 ;
35005 PyObject *swig_obj[1] ;
35006
35007 if (!args) SWIG_fail;
35008 swig_obj[0] = args;
35009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35010 if (!SWIG_IsOK(res1)) {
35011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35012 }
35013 arg1 = reinterpret_cast< wxWindow * >(argp1);
35014 {
35015 PyThreadState* __tstate = wxPyBeginAllowThreads();
35016 result = (arg1)->GetFont();
35017 wxPyEndAllowThreads(__tstate);
35018 if (PyErr_Occurred()) SWIG_fail;
35019 }
35020 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35021 return resultobj;
35022 fail:
35023 return NULL;
35024 }
35025
35026
35027 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35028 PyObject *resultobj = 0;
35029 wxWindow *arg1 = (wxWindow *) 0 ;
35030 wxCaret *arg2 = (wxCaret *) 0 ;
35031 void *argp1 = 0 ;
35032 int res1 = 0 ;
35033 int res2 = 0 ;
35034 PyObject * obj0 = 0 ;
35035 PyObject * obj1 = 0 ;
35036 char * kwnames[] = {
35037 (char *) "self",(char *) "caret", NULL
35038 };
35039
35040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35042 if (!SWIG_IsOK(res1)) {
35043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35044 }
35045 arg1 = reinterpret_cast< wxWindow * >(argp1);
35046 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35047 if (!SWIG_IsOK(res2)) {
35048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35049 }
35050 {
35051 PyThreadState* __tstate = wxPyBeginAllowThreads();
35052 (arg1)->SetCaret(arg2);
35053 wxPyEndAllowThreads(__tstate);
35054 if (PyErr_Occurred()) SWIG_fail;
35055 }
35056 resultobj = SWIG_Py_Void();
35057 return resultobj;
35058 fail:
35059 return NULL;
35060 }
35061
35062
35063 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35064 PyObject *resultobj = 0;
35065 wxWindow *arg1 = (wxWindow *) 0 ;
35066 wxCaret *result = 0 ;
35067 void *argp1 = 0 ;
35068 int res1 = 0 ;
35069 PyObject *swig_obj[1] ;
35070
35071 if (!args) SWIG_fail;
35072 swig_obj[0] = args;
35073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35074 if (!SWIG_IsOK(res1)) {
35075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35076 }
35077 arg1 = reinterpret_cast< wxWindow * >(argp1);
35078 {
35079 PyThreadState* __tstate = wxPyBeginAllowThreads();
35080 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35081 wxPyEndAllowThreads(__tstate);
35082 if (PyErr_Occurred()) SWIG_fail;
35083 }
35084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35085 return resultobj;
35086 fail:
35087 return NULL;
35088 }
35089
35090
35091 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35092 PyObject *resultobj = 0;
35093 wxWindow *arg1 = (wxWindow *) 0 ;
35094 int result;
35095 void *argp1 = 0 ;
35096 int res1 = 0 ;
35097 PyObject *swig_obj[1] ;
35098
35099 if (!args) SWIG_fail;
35100 swig_obj[0] = args;
35101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35102 if (!SWIG_IsOK(res1)) {
35103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35104 }
35105 arg1 = reinterpret_cast< wxWindow * >(argp1);
35106 {
35107 PyThreadState* __tstate = wxPyBeginAllowThreads();
35108 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35109 wxPyEndAllowThreads(__tstate);
35110 if (PyErr_Occurred()) SWIG_fail;
35111 }
35112 resultobj = SWIG_From_int(static_cast< int >(result));
35113 return resultobj;
35114 fail:
35115 return NULL;
35116 }
35117
35118
35119 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35120 PyObject *resultobj = 0;
35121 wxWindow *arg1 = (wxWindow *) 0 ;
35122 int result;
35123 void *argp1 = 0 ;
35124 int res1 = 0 ;
35125 PyObject *swig_obj[1] ;
35126
35127 if (!args) SWIG_fail;
35128 swig_obj[0] = args;
35129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35130 if (!SWIG_IsOK(res1)) {
35131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35132 }
35133 arg1 = reinterpret_cast< wxWindow * >(argp1);
35134 {
35135 PyThreadState* __tstate = wxPyBeginAllowThreads();
35136 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35137 wxPyEndAllowThreads(__tstate);
35138 if (PyErr_Occurred()) SWIG_fail;
35139 }
35140 resultobj = SWIG_From_int(static_cast< int >(result));
35141 return resultobj;
35142 fail:
35143 return NULL;
35144 }
35145
35146
35147 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35148 PyObject *resultobj = 0;
35149 wxWindow *arg1 = (wxWindow *) 0 ;
35150 wxString *arg2 = 0 ;
35151 int *arg3 = (int *) 0 ;
35152 int *arg4 = (int *) 0 ;
35153 void *argp1 = 0 ;
35154 int res1 = 0 ;
35155 bool temp2 = false ;
35156 int temp3 ;
35157 int res3 = SWIG_TMPOBJ ;
35158 int temp4 ;
35159 int res4 = SWIG_TMPOBJ ;
35160 PyObject * obj0 = 0 ;
35161 PyObject * obj1 = 0 ;
35162 char * kwnames[] = {
35163 (char *) "self",(char *) "string", NULL
35164 };
35165
35166 arg3 = &temp3;
35167 arg4 = &temp4;
35168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35170 if (!SWIG_IsOK(res1)) {
35171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35172 }
35173 arg1 = reinterpret_cast< wxWindow * >(argp1);
35174 {
35175 arg2 = wxString_in_helper(obj1);
35176 if (arg2 == NULL) SWIG_fail;
35177 temp2 = true;
35178 }
35179 {
35180 PyThreadState* __tstate = wxPyBeginAllowThreads();
35181 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35182 wxPyEndAllowThreads(__tstate);
35183 if (PyErr_Occurred()) SWIG_fail;
35184 }
35185 resultobj = SWIG_Py_Void();
35186 if (SWIG_IsTmpObj(res3)) {
35187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35188 } else {
35189 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35191 }
35192 if (SWIG_IsTmpObj(res4)) {
35193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35194 } else {
35195 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35197 }
35198 {
35199 if (temp2)
35200 delete arg2;
35201 }
35202 return resultobj;
35203 fail:
35204 {
35205 if (temp2)
35206 delete arg2;
35207 }
35208 return NULL;
35209 }
35210
35211
35212 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35213 PyObject *resultobj = 0;
35214 wxWindow *arg1 = (wxWindow *) 0 ;
35215 wxString *arg2 = 0 ;
35216 int *arg3 = (int *) 0 ;
35217 int *arg4 = (int *) 0 ;
35218 int *arg5 = (int *) 0 ;
35219 int *arg6 = (int *) 0 ;
35220 wxFont *arg7 = (wxFont *) NULL ;
35221 void *argp1 = 0 ;
35222 int res1 = 0 ;
35223 bool temp2 = false ;
35224 int temp3 ;
35225 int res3 = SWIG_TMPOBJ ;
35226 int temp4 ;
35227 int res4 = SWIG_TMPOBJ ;
35228 int temp5 ;
35229 int res5 = SWIG_TMPOBJ ;
35230 int temp6 ;
35231 int res6 = SWIG_TMPOBJ ;
35232 void *argp7 = 0 ;
35233 int res7 = 0 ;
35234 PyObject * obj0 = 0 ;
35235 PyObject * obj1 = 0 ;
35236 PyObject * obj2 = 0 ;
35237 char * kwnames[] = {
35238 (char *) "self",(char *) "string",(char *) "font", NULL
35239 };
35240
35241 arg3 = &temp3;
35242 arg4 = &temp4;
35243 arg5 = &temp5;
35244 arg6 = &temp6;
35245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35247 if (!SWIG_IsOK(res1)) {
35248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35249 }
35250 arg1 = reinterpret_cast< wxWindow * >(argp1);
35251 {
35252 arg2 = wxString_in_helper(obj1);
35253 if (arg2 == NULL) SWIG_fail;
35254 temp2 = true;
35255 }
35256 if (obj2) {
35257 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35258 if (!SWIG_IsOK(res7)) {
35259 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35260 }
35261 arg7 = reinterpret_cast< wxFont * >(argp7);
35262 }
35263 {
35264 PyThreadState* __tstate = wxPyBeginAllowThreads();
35265 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35266 wxPyEndAllowThreads(__tstate);
35267 if (PyErr_Occurred()) SWIG_fail;
35268 }
35269 resultobj = SWIG_Py_Void();
35270 if (SWIG_IsTmpObj(res3)) {
35271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35272 } else {
35273 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35274 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35275 }
35276 if (SWIG_IsTmpObj(res4)) {
35277 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35278 } else {
35279 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35280 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35281 }
35282 if (SWIG_IsTmpObj(res5)) {
35283 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35284 } else {
35285 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35286 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35287 }
35288 if (SWIG_IsTmpObj(res6)) {
35289 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35290 } else {
35291 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35292 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35293 }
35294 {
35295 if (temp2)
35296 delete arg2;
35297 }
35298 return resultobj;
35299 fail:
35300 {
35301 if (temp2)
35302 delete arg2;
35303 }
35304 return NULL;
35305 }
35306
35307
35308 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35309 PyObject *resultobj = 0;
35310 wxWindow *arg1 = (wxWindow *) 0 ;
35311 int *arg2 = (int *) 0 ;
35312 int *arg3 = (int *) 0 ;
35313 void *argp1 = 0 ;
35314 int res1 = 0 ;
35315 int temp2 ;
35316 int res2 = 0 ;
35317 int temp3 ;
35318 int res3 = 0 ;
35319 PyObject * obj0 = 0 ;
35320 PyObject * obj1 = 0 ;
35321 PyObject * obj2 = 0 ;
35322 char * kwnames[] = {
35323 (char *) "self",(char *) "x",(char *) "y", NULL
35324 };
35325
35326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35328 if (!SWIG_IsOK(res1)) {
35329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35330 }
35331 arg1 = reinterpret_cast< wxWindow * >(argp1);
35332 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35333 int val;
35334 int ecode = SWIG_AsVal_int(obj1, &val);
35335 if (!SWIG_IsOK(ecode)) {
35336 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35337 }
35338 temp2 = static_cast< int >(val);
35339 arg2 = &temp2;
35340 res2 = SWIG_AddTmpMask(ecode);
35341 }
35342 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35343 int val;
35344 int ecode = SWIG_AsVal_int(obj2, &val);
35345 if (!SWIG_IsOK(ecode)) {
35346 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35347 }
35348 temp3 = static_cast< int >(val);
35349 arg3 = &temp3;
35350 res3 = SWIG_AddTmpMask(ecode);
35351 }
35352 {
35353 PyThreadState* __tstate = wxPyBeginAllowThreads();
35354 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35355 wxPyEndAllowThreads(__tstate);
35356 if (PyErr_Occurred()) SWIG_fail;
35357 }
35358 resultobj = SWIG_Py_Void();
35359 if (SWIG_IsTmpObj(res2)) {
35360 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35361 } else {
35362 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35364 }
35365 if (SWIG_IsTmpObj(res3)) {
35366 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35367 } else {
35368 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35370 }
35371 return resultobj;
35372 fail:
35373 return NULL;
35374 }
35375
35376
35377 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35378 PyObject *resultobj = 0;
35379 wxWindow *arg1 = (wxWindow *) 0 ;
35380 int *arg2 = (int *) 0 ;
35381 int *arg3 = (int *) 0 ;
35382 void *argp1 = 0 ;
35383 int res1 = 0 ;
35384 int temp2 ;
35385 int res2 = 0 ;
35386 int temp3 ;
35387 int res3 = 0 ;
35388 PyObject * obj0 = 0 ;
35389 PyObject * obj1 = 0 ;
35390 PyObject * obj2 = 0 ;
35391 char * kwnames[] = {
35392 (char *) "self",(char *) "x",(char *) "y", NULL
35393 };
35394
35395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35397 if (!SWIG_IsOK(res1)) {
35398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35399 }
35400 arg1 = reinterpret_cast< wxWindow * >(argp1);
35401 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35402 int val;
35403 int ecode = SWIG_AsVal_int(obj1, &val);
35404 if (!SWIG_IsOK(ecode)) {
35405 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35406 }
35407 temp2 = static_cast< int >(val);
35408 arg2 = &temp2;
35409 res2 = SWIG_AddTmpMask(ecode);
35410 }
35411 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35412 int val;
35413 int ecode = SWIG_AsVal_int(obj2, &val);
35414 if (!SWIG_IsOK(ecode)) {
35415 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35416 }
35417 temp3 = static_cast< int >(val);
35418 arg3 = &temp3;
35419 res3 = SWIG_AddTmpMask(ecode);
35420 }
35421 {
35422 PyThreadState* __tstate = wxPyBeginAllowThreads();
35423 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35424 wxPyEndAllowThreads(__tstate);
35425 if (PyErr_Occurred()) SWIG_fail;
35426 }
35427 resultobj = SWIG_Py_Void();
35428 if (SWIG_IsTmpObj(res2)) {
35429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35430 } else {
35431 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35432 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35433 }
35434 if (SWIG_IsTmpObj(res3)) {
35435 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35436 } else {
35437 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35439 }
35440 return resultobj;
35441 fail:
35442 return NULL;
35443 }
35444
35445
35446 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35447 PyObject *resultobj = 0;
35448 wxWindow *arg1 = (wxWindow *) 0 ;
35449 wxPoint *arg2 = 0 ;
35450 wxPoint result;
35451 void *argp1 = 0 ;
35452 int res1 = 0 ;
35453 wxPoint temp2 ;
35454 PyObject * obj0 = 0 ;
35455 PyObject * obj1 = 0 ;
35456 char * kwnames[] = {
35457 (char *) "self",(char *) "pt", NULL
35458 };
35459
35460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35462 if (!SWIG_IsOK(res1)) {
35463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35464 }
35465 arg1 = reinterpret_cast< wxWindow * >(argp1);
35466 {
35467 arg2 = &temp2;
35468 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35469 }
35470 {
35471 PyThreadState* __tstate = wxPyBeginAllowThreads();
35472 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35473 wxPyEndAllowThreads(__tstate);
35474 if (PyErr_Occurred()) SWIG_fail;
35475 }
35476 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35477 return resultobj;
35478 fail:
35479 return NULL;
35480 }
35481
35482
35483 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35484 PyObject *resultobj = 0;
35485 wxWindow *arg1 = (wxWindow *) 0 ;
35486 wxPoint *arg2 = 0 ;
35487 wxPoint result;
35488 void *argp1 = 0 ;
35489 int res1 = 0 ;
35490 wxPoint temp2 ;
35491 PyObject * obj0 = 0 ;
35492 PyObject * obj1 = 0 ;
35493 char * kwnames[] = {
35494 (char *) "self",(char *) "pt", NULL
35495 };
35496
35497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35499 if (!SWIG_IsOK(res1)) {
35500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35501 }
35502 arg1 = reinterpret_cast< wxWindow * >(argp1);
35503 {
35504 arg2 = &temp2;
35505 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35506 }
35507 {
35508 PyThreadState* __tstate = wxPyBeginAllowThreads();
35509 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35510 wxPyEndAllowThreads(__tstate);
35511 if (PyErr_Occurred()) SWIG_fail;
35512 }
35513 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35514 return resultobj;
35515 fail:
35516 return NULL;
35517 }
35518
35519
35520 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35521 PyObject *resultobj = 0;
35522 wxWindow *arg1 = (wxWindow *) 0 ;
35523 int arg2 ;
35524 int arg3 ;
35525 wxHitTest result;
35526 void *argp1 = 0 ;
35527 int res1 = 0 ;
35528 int val2 ;
35529 int ecode2 = 0 ;
35530 int val3 ;
35531 int ecode3 = 0 ;
35532 PyObject * obj0 = 0 ;
35533 PyObject * obj1 = 0 ;
35534 PyObject * obj2 = 0 ;
35535 char * kwnames[] = {
35536 (char *) "self",(char *) "x",(char *) "y", NULL
35537 };
35538
35539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35541 if (!SWIG_IsOK(res1)) {
35542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35543 }
35544 arg1 = reinterpret_cast< wxWindow * >(argp1);
35545 ecode2 = SWIG_AsVal_int(obj1, &val2);
35546 if (!SWIG_IsOK(ecode2)) {
35547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35548 }
35549 arg2 = static_cast< int >(val2);
35550 ecode3 = SWIG_AsVal_int(obj2, &val3);
35551 if (!SWIG_IsOK(ecode3)) {
35552 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35553 }
35554 arg3 = static_cast< int >(val3);
35555 {
35556 PyThreadState* __tstate = wxPyBeginAllowThreads();
35557 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35558 wxPyEndAllowThreads(__tstate);
35559 if (PyErr_Occurred()) SWIG_fail;
35560 }
35561 resultobj = SWIG_From_int(static_cast< int >(result));
35562 return resultobj;
35563 fail:
35564 return NULL;
35565 }
35566
35567
35568 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35569 PyObject *resultobj = 0;
35570 wxWindow *arg1 = (wxWindow *) 0 ;
35571 wxPoint *arg2 = 0 ;
35572 wxHitTest result;
35573 void *argp1 = 0 ;
35574 int res1 = 0 ;
35575 wxPoint temp2 ;
35576 PyObject * obj0 = 0 ;
35577 PyObject * obj1 = 0 ;
35578 char * kwnames[] = {
35579 (char *) "self",(char *) "pt", NULL
35580 };
35581
35582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35584 if (!SWIG_IsOK(res1)) {
35585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35586 }
35587 arg1 = reinterpret_cast< wxWindow * >(argp1);
35588 {
35589 arg2 = &temp2;
35590 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35591 }
35592 {
35593 PyThreadState* __tstate = wxPyBeginAllowThreads();
35594 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35595 wxPyEndAllowThreads(__tstate);
35596 if (PyErr_Occurred()) SWIG_fail;
35597 }
35598 resultobj = SWIG_From_int(static_cast< int >(result));
35599 return resultobj;
35600 fail:
35601 return NULL;
35602 }
35603
35604
35605 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35606 PyObject *resultobj = 0;
35607 wxWindow *arg1 = (wxWindow *) 0 ;
35608 long arg2 ;
35609 wxBorder result;
35610 void *argp1 = 0 ;
35611 int res1 = 0 ;
35612 long val2 ;
35613 int ecode2 = 0 ;
35614
35615 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35617 if (!SWIG_IsOK(res1)) {
35618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35619 }
35620 arg1 = reinterpret_cast< wxWindow * >(argp1);
35621 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35622 if (!SWIG_IsOK(ecode2)) {
35623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35624 }
35625 arg2 = static_cast< long >(val2);
35626 {
35627 PyThreadState* __tstate = wxPyBeginAllowThreads();
35628 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35629 wxPyEndAllowThreads(__tstate);
35630 if (PyErr_Occurred()) SWIG_fail;
35631 }
35632 resultobj = SWIG_From_int(static_cast< int >(result));
35633 return resultobj;
35634 fail:
35635 return NULL;
35636 }
35637
35638
35639 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35640 PyObject *resultobj = 0;
35641 wxWindow *arg1 = (wxWindow *) 0 ;
35642 wxBorder result;
35643 void *argp1 = 0 ;
35644 int res1 = 0 ;
35645
35646 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35648 if (!SWIG_IsOK(res1)) {
35649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35650 }
35651 arg1 = reinterpret_cast< wxWindow * >(argp1);
35652 {
35653 PyThreadState* __tstate = wxPyBeginAllowThreads();
35654 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35655 wxPyEndAllowThreads(__tstate);
35656 if (PyErr_Occurred()) SWIG_fail;
35657 }
35658 resultobj = SWIG_From_int(static_cast< int >(result));
35659 return resultobj;
35660 fail:
35661 return NULL;
35662 }
35663
35664
35665 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35666 int argc;
35667 PyObject *argv[3];
35668
35669 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35670 --argc;
35671 if (argc == 1) {
35672 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35673 }
35674 if (argc == 2) {
35675 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35676 }
35677
35678 fail:
35679 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35680 return NULL;
35681 }
35682
35683
35684 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35685 PyObject *resultobj = 0;
35686 wxWindow *arg1 = (wxWindow *) 0 ;
35687 long arg2 = (long) wxUPDATE_UI_NONE ;
35688 void *argp1 = 0 ;
35689 int res1 = 0 ;
35690 long val2 ;
35691 int ecode2 = 0 ;
35692 PyObject * obj0 = 0 ;
35693 PyObject * obj1 = 0 ;
35694 char * kwnames[] = {
35695 (char *) "self",(char *) "flags", NULL
35696 };
35697
35698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35700 if (!SWIG_IsOK(res1)) {
35701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35702 }
35703 arg1 = reinterpret_cast< wxWindow * >(argp1);
35704 if (obj1) {
35705 ecode2 = SWIG_AsVal_long(obj1, &val2);
35706 if (!SWIG_IsOK(ecode2)) {
35707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35708 }
35709 arg2 = static_cast< long >(val2);
35710 }
35711 {
35712 PyThreadState* __tstate = wxPyBeginAllowThreads();
35713 (arg1)->UpdateWindowUI(arg2);
35714 wxPyEndAllowThreads(__tstate);
35715 if (PyErr_Occurred()) SWIG_fail;
35716 }
35717 resultobj = SWIG_Py_Void();
35718 return resultobj;
35719 fail:
35720 return NULL;
35721 }
35722
35723
35724 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35725 PyObject *resultobj = 0;
35726 wxWindow *arg1 = (wxWindow *) 0 ;
35727 wxMenu *arg2 = (wxMenu *) 0 ;
35728 int arg3 = (int) -1 ;
35729 int arg4 = (int) -1 ;
35730 bool result;
35731 void *argp1 = 0 ;
35732 int res1 = 0 ;
35733 void *argp2 = 0 ;
35734 int res2 = 0 ;
35735 int val3 ;
35736 int ecode3 = 0 ;
35737 int val4 ;
35738 int ecode4 = 0 ;
35739 PyObject * obj0 = 0 ;
35740 PyObject * obj1 = 0 ;
35741 PyObject * obj2 = 0 ;
35742 PyObject * obj3 = 0 ;
35743 char * kwnames[] = {
35744 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35745 };
35746
35747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35749 if (!SWIG_IsOK(res1)) {
35750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35751 }
35752 arg1 = reinterpret_cast< wxWindow * >(argp1);
35753 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35754 if (!SWIG_IsOK(res2)) {
35755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35756 }
35757 arg2 = reinterpret_cast< wxMenu * >(argp2);
35758 if (obj2) {
35759 ecode3 = SWIG_AsVal_int(obj2, &val3);
35760 if (!SWIG_IsOK(ecode3)) {
35761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35762 }
35763 arg3 = static_cast< int >(val3);
35764 }
35765 if (obj3) {
35766 ecode4 = SWIG_AsVal_int(obj3, &val4);
35767 if (!SWIG_IsOK(ecode4)) {
35768 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35769 }
35770 arg4 = static_cast< int >(val4);
35771 }
35772 {
35773 PyThreadState* __tstate = wxPyBeginAllowThreads();
35774 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35775 wxPyEndAllowThreads(__tstate);
35776 if (PyErr_Occurred()) SWIG_fail;
35777 }
35778 {
35779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35780 }
35781 return resultobj;
35782 fail:
35783 return NULL;
35784 }
35785
35786
35787 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35788 PyObject *resultobj = 0;
35789 wxWindow *arg1 = (wxWindow *) 0 ;
35790 wxMenu *arg2 = (wxMenu *) 0 ;
35791 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35792 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35793 bool result;
35794 void *argp1 = 0 ;
35795 int res1 = 0 ;
35796 void *argp2 = 0 ;
35797 int res2 = 0 ;
35798 wxPoint temp3 ;
35799 PyObject * obj0 = 0 ;
35800 PyObject * obj1 = 0 ;
35801 PyObject * obj2 = 0 ;
35802 char * kwnames[] = {
35803 (char *) "self",(char *) "menu",(char *) "pos", NULL
35804 };
35805
35806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35808 if (!SWIG_IsOK(res1)) {
35809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
35810 }
35811 arg1 = reinterpret_cast< wxWindow * >(argp1);
35812 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35813 if (!SWIG_IsOK(res2)) {
35814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
35815 }
35816 arg2 = reinterpret_cast< wxMenu * >(argp2);
35817 if (obj2) {
35818 {
35819 arg3 = &temp3;
35820 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
35821 }
35822 }
35823 {
35824 PyThreadState* __tstate = wxPyBeginAllowThreads();
35825 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
35826 wxPyEndAllowThreads(__tstate);
35827 if (PyErr_Occurred()) SWIG_fail;
35828 }
35829 {
35830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35831 }
35832 return resultobj;
35833 fail:
35834 return NULL;
35835 }
35836
35837
35838 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35839 PyObject *resultobj = 0;
35840 wxWindow *arg1 = (wxWindow *) 0 ;
35841 long result;
35842 void *argp1 = 0 ;
35843 int res1 = 0 ;
35844 PyObject *swig_obj[1] ;
35845
35846 if (!args) SWIG_fail;
35847 swig_obj[0] = args;
35848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35849 if (!SWIG_IsOK(res1)) {
35850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35851 }
35852 arg1 = reinterpret_cast< wxWindow * >(argp1);
35853 {
35854 PyThreadState* __tstate = wxPyBeginAllowThreads();
35855 result = (long)wxWindow_GetHandle(arg1);
35856 wxPyEndAllowThreads(__tstate);
35857 if (PyErr_Occurred()) SWIG_fail;
35858 }
35859 resultobj = SWIG_From_long(static_cast< long >(result));
35860 return resultobj;
35861 fail:
35862 return NULL;
35863 }
35864
35865
35866 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35867 PyObject *resultobj = 0;
35868 wxWindow *arg1 = (wxWindow *) 0 ;
35869 long arg2 ;
35870 void *argp1 = 0 ;
35871 int res1 = 0 ;
35872 long val2 ;
35873 int ecode2 = 0 ;
35874 PyObject * obj0 = 0 ;
35875 PyObject * obj1 = 0 ;
35876 char * kwnames[] = {
35877 (char *) "self",(char *) "handle", NULL
35878 };
35879
35880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
35881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35882 if (!SWIG_IsOK(res1)) {
35883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35884 }
35885 arg1 = reinterpret_cast< wxWindow * >(argp1);
35886 ecode2 = SWIG_AsVal_long(obj1, &val2);
35887 if (!SWIG_IsOK(ecode2)) {
35888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
35889 }
35890 arg2 = static_cast< long >(val2);
35891 {
35892 PyThreadState* __tstate = wxPyBeginAllowThreads();
35893 wxWindow_AssociateHandle(arg1,arg2);
35894 wxPyEndAllowThreads(__tstate);
35895 if (PyErr_Occurred()) SWIG_fail;
35896 }
35897 resultobj = SWIG_Py_Void();
35898 return resultobj;
35899 fail:
35900 return NULL;
35901 }
35902
35903
35904 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35905 PyObject *resultobj = 0;
35906 wxWindow *arg1 = (wxWindow *) 0 ;
35907 void *argp1 = 0 ;
35908 int res1 = 0 ;
35909 PyObject *swig_obj[1] ;
35910
35911 if (!args) SWIG_fail;
35912 swig_obj[0] = args;
35913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35914 if (!SWIG_IsOK(res1)) {
35915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35916 }
35917 arg1 = reinterpret_cast< wxWindow * >(argp1);
35918 {
35919 PyThreadState* __tstate = wxPyBeginAllowThreads();
35920 (arg1)->DissociateHandle();
35921 wxPyEndAllowThreads(__tstate);
35922 if (PyErr_Occurred()) SWIG_fail;
35923 }
35924 resultobj = SWIG_Py_Void();
35925 return resultobj;
35926 fail:
35927 return NULL;
35928 }
35929
35930
35931 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35932 PyObject *resultobj = 0;
35933 wxWindow *arg1 = (wxWindow *) 0 ;
35934 int arg2 ;
35935 bool result;
35936 void *argp1 = 0 ;
35937 int res1 = 0 ;
35938 int val2 ;
35939 int ecode2 = 0 ;
35940 PyObject * obj0 = 0 ;
35941 PyObject * obj1 = 0 ;
35942 char * kwnames[] = {
35943 (char *) "self",(char *) "orient", NULL
35944 };
35945
35946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
35947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35948 if (!SWIG_IsOK(res1)) {
35949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
35950 }
35951 arg1 = reinterpret_cast< wxWindow * >(argp1);
35952 ecode2 = SWIG_AsVal_int(obj1, &val2);
35953 if (!SWIG_IsOK(ecode2)) {
35954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
35955 }
35956 arg2 = static_cast< int >(val2);
35957 {
35958 PyThreadState* __tstate = wxPyBeginAllowThreads();
35959 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
35960 wxPyEndAllowThreads(__tstate);
35961 if (PyErr_Occurred()) SWIG_fail;
35962 }
35963 {
35964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35965 }
35966 return resultobj;
35967 fail:
35968 return NULL;
35969 }
35970
35971
35972 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35973 PyObject *resultobj = 0;
35974 wxWindow *arg1 = (wxWindow *) 0 ;
35975 int arg2 ;
35976 int arg3 ;
35977 int arg4 ;
35978 int arg5 ;
35979 bool arg6 = (bool) true ;
35980 void *argp1 = 0 ;
35981 int res1 = 0 ;
35982 int val2 ;
35983 int ecode2 = 0 ;
35984 int val3 ;
35985 int ecode3 = 0 ;
35986 int val4 ;
35987 int ecode4 = 0 ;
35988 int val5 ;
35989 int ecode5 = 0 ;
35990 bool val6 ;
35991 int ecode6 = 0 ;
35992 PyObject * obj0 = 0 ;
35993 PyObject * obj1 = 0 ;
35994 PyObject * obj2 = 0 ;
35995 PyObject * obj3 = 0 ;
35996 PyObject * obj4 = 0 ;
35997 PyObject * obj5 = 0 ;
35998 char * kwnames[] = {
35999 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36000 };
36001
36002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36004 if (!SWIG_IsOK(res1)) {
36005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36006 }
36007 arg1 = reinterpret_cast< wxWindow * >(argp1);
36008 ecode2 = SWIG_AsVal_int(obj1, &val2);
36009 if (!SWIG_IsOK(ecode2)) {
36010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36011 }
36012 arg2 = static_cast< int >(val2);
36013 ecode3 = SWIG_AsVal_int(obj2, &val3);
36014 if (!SWIG_IsOK(ecode3)) {
36015 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36016 }
36017 arg3 = static_cast< int >(val3);
36018 ecode4 = SWIG_AsVal_int(obj3, &val4);
36019 if (!SWIG_IsOK(ecode4)) {
36020 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36021 }
36022 arg4 = static_cast< int >(val4);
36023 ecode5 = SWIG_AsVal_int(obj4, &val5);
36024 if (!SWIG_IsOK(ecode5)) {
36025 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36026 }
36027 arg5 = static_cast< int >(val5);
36028 if (obj5) {
36029 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36030 if (!SWIG_IsOK(ecode6)) {
36031 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36032 }
36033 arg6 = static_cast< bool >(val6);
36034 }
36035 {
36036 PyThreadState* __tstate = wxPyBeginAllowThreads();
36037 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36038 wxPyEndAllowThreads(__tstate);
36039 if (PyErr_Occurred()) SWIG_fail;
36040 }
36041 resultobj = SWIG_Py_Void();
36042 return resultobj;
36043 fail:
36044 return NULL;
36045 }
36046
36047
36048 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36049 PyObject *resultobj = 0;
36050 wxWindow *arg1 = (wxWindow *) 0 ;
36051 int arg2 ;
36052 int arg3 ;
36053 bool arg4 = (bool) true ;
36054 void *argp1 = 0 ;
36055 int res1 = 0 ;
36056 int val2 ;
36057 int ecode2 = 0 ;
36058 int val3 ;
36059 int ecode3 = 0 ;
36060 bool val4 ;
36061 int ecode4 = 0 ;
36062 PyObject * obj0 = 0 ;
36063 PyObject * obj1 = 0 ;
36064 PyObject * obj2 = 0 ;
36065 PyObject * obj3 = 0 ;
36066 char * kwnames[] = {
36067 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36068 };
36069
36070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36072 if (!SWIG_IsOK(res1)) {
36073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36074 }
36075 arg1 = reinterpret_cast< wxWindow * >(argp1);
36076 ecode2 = SWIG_AsVal_int(obj1, &val2);
36077 if (!SWIG_IsOK(ecode2)) {
36078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36079 }
36080 arg2 = static_cast< int >(val2);
36081 ecode3 = SWIG_AsVal_int(obj2, &val3);
36082 if (!SWIG_IsOK(ecode3)) {
36083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36084 }
36085 arg3 = static_cast< int >(val3);
36086 if (obj3) {
36087 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36088 if (!SWIG_IsOK(ecode4)) {
36089 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36090 }
36091 arg4 = static_cast< bool >(val4);
36092 }
36093 {
36094 PyThreadState* __tstate = wxPyBeginAllowThreads();
36095 (arg1)->SetScrollPos(arg2,arg3,arg4);
36096 wxPyEndAllowThreads(__tstate);
36097 if (PyErr_Occurred()) SWIG_fail;
36098 }
36099 resultobj = SWIG_Py_Void();
36100 return resultobj;
36101 fail:
36102 return NULL;
36103 }
36104
36105
36106 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36107 PyObject *resultobj = 0;
36108 wxWindow *arg1 = (wxWindow *) 0 ;
36109 int arg2 ;
36110 int result;
36111 void *argp1 = 0 ;
36112 int res1 = 0 ;
36113 int val2 ;
36114 int ecode2 = 0 ;
36115 PyObject * obj0 = 0 ;
36116 PyObject * obj1 = 0 ;
36117 char * kwnames[] = {
36118 (char *) "self",(char *) "orientation", NULL
36119 };
36120
36121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36123 if (!SWIG_IsOK(res1)) {
36124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36125 }
36126 arg1 = reinterpret_cast< wxWindow * >(argp1);
36127 ecode2 = SWIG_AsVal_int(obj1, &val2);
36128 if (!SWIG_IsOK(ecode2)) {
36129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36130 }
36131 arg2 = static_cast< int >(val2);
36132 {
36133 PyThreadState* __tstate = wxPyBeginAllowThreads();
36134 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36135 wxPyEndAllowThreads(__tstate);
36136 if (PyErr_Occurred()) SWIG_fail;
36137 }
36138 resultobj = SWIG_From_int(static_cast< int >(result));
36139 return resultobj;
36140 fail:
36141 return NULL;
36142 }
36143
36144
36145 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36146 PyObject *resultobj = 0;
36147 wxWindow *arg1 = (wxWindow *) 0 ;
36148 int arg2 ;
36149 int result;
36150 void *argp1 = 0 ;
36151 int res1 = 0 ;
36152 int val2 ;
36153 int ecode2 = 0 ;
36154 PyObject * obj0 = 0 ;
36155 PyObject * obj1 = 0 ;
36156 char * kwnames[] = {
36157 (char *) "self",(char *) "orientation", NULL
36158 };
36159
36160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36162 if (!SWIG_IsOK(res1)) {
36163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36164 }
36165 arg1 = reinterpret_cast< wxWindow * >(argp1);
36166 ecode2 = SWIG_AsVal_int(obj1, &val2);
36167 if (!SWIG_IsOK(ecode2)) {
36168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36169 }
36170 arg2 = static_cast< int >(val2);
36171 {
36172 PyThreadState* __tstate = wxPyBeginAllowThreads();
36173 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36174 wxPyEndAllowThreads(__tstate);
36175 if (PyErr_Occurred()) SWIG_fail;
36176 }
36177 resultobj = SWIG_From_int(static_cast< int >(result));
36178 return resultobj;
36179 fail:
36180 return NULL;
36181 }
36182
36183
36184 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36185 PyObject *resultobj = 0;
36186 wxWindow *arg1 = (wxWindow *) 0 ;
36187 int arg2 ;
36188 int result;
36189 void *argp1 = 0 ;
36190 int res1 = 0 ;
36191 int val2 ;
36192 int ecode2 = 0 ;
36193 PyObject * obj0 = 0 ;
36194 PyObject * obj1 = 0 ;
36195 char * kwnames[] = {
36196 (char *) "self",(char *) "orientation", NULL
36197 };
36198
36199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36201 if (!SWIG_IsOK(res1)) {
36202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36203 }
36204 arg1 = reinterpret_cast< wxWindow * >(argp1);
36205 ecode2 = SWIG_AsVal_int(obj1, &val2);
36206 if (!SWIG_IsOK(ecode2)) {
36207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36208 }
36209 arg2 = static_cast< int >(val2);
36210 {
36211 PyThreadState* __tstate = wxPyBeginAllowThreads();
36212 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36213 wxPyEndAllowThreads(__tstate);
36214 if (PyErr_Occurred()) SWIG_fail;
36215 }
36216 resultobj = SWIG_From_int(static_cast< int >(result));
36217 return resultobj;
36218 fail:
36219 return NULL;
36220 }
36221
36222
36223 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36224 PyObject *resultobj = 0;
36225 wxWindow *arg1 = (wxWindow *) 0 ;
36226 int arg2 ;
36227 int arg3 ;
36228 wxRect *arg4 = (wxRect *) NULL ;
36229 void *argp1 = 0 ;
36230 int res1 = 0 ;
36231 int val2 ;
36232 int ecode2 = 0 ;
36233 int val3 ;
36234 int ecode3 = 0 ;
36235 void *argp4 = 0 ;
36236 int res4 = 0 ;
36237 PyObject * obj0 = 0 ;
36238 PyObject * obj1 = 0 ;
36239 PyObject * obj2 = 0 ;
36240 PyObject * obj3 = 0 ;
36241 char * kwnames[] = {
36242 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36243 };
36244
36245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36247 if (!SWIG_IsOK(res1)) {
36248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36249 }
36250 arg1 = reinterpret_cast< wxWindow * >(argp1);
36251 ecode2 = SWIG_AsVal_int(obj1, &val2);
36252 if (!SWIG_IsOK(ecode2)) {
36253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36254 }
36255 arg2 = static_cast< int >(val2);
36256 ecode3 = SWIG_AsVal_int(obj2, &val3);
36257 if (!SWIG_IsOK(ecode3)) {
36258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36259 }
36260 arg3 = static_cast< int >(val3);
36261 if (obj3) {
36262 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36263 if (!SWIG_IsOK(res4)) {
36264 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36265 }
36266 arg4 = reinterpret_cast< wxRect * >(argp4);
36267 }
36268 {
36269 PyThreadState* __tstate = wxPyBeginAllowThreads();
36270 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36271 wxPyEndAllowThreads(__tstate);
36272 if (PyErr_Occurred()) SWIG_fail;
36273 }
36274 resultobj = SWIG_Py_Void();
36275 return resultobj;
36276 fail:
36277 return NULL;
36278 }
36279
36280
36281 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36282 PyObject *resultobj = 0;
36283 wxWindow *arg1 = (wxWindow *) 0 ;
36284 int arg2 ;
36285 bool result;
36286 void *argp1 = 0 ;
36287 int res1 = 0 ;
36288 int val2 ;
36289 int ecode2 = 0 ;
36290 PyObject * obj0 = 0 ;
36291 PyObject * obj1 = 0 ;
36292 char * kwnames[] = {
36293 (char *) "self",(char *) "lines", NULL
36294 };
36295
36296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36298 if (!SWIG_IsOK(res1)) {
36299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36300 }
36301 arg1 = reinterpret_cast< wxWindow * >(argp1);
36302 ecode2 = SWIG_AsVal_int(obj1, &val2);
36303 if (!SWIG_IsOK(ecode2)) {
36304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36305 }
36306 arg2 = static_cast< int >(val2);
36307 {
36308 PyThreadState* __tstate = wxPyBeginAllowThreads();
36309 result = (bool)(arg1)->ScrollLines(arg2);
36310 wxPyEndAllowThreads(__tstate);
36311 if (PyErr_Occurred()) SWIG_fail;
36312 }
36313 {
36314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36315 }
36316 return resultobj;
36317 fail:
36318 return NULL;
36319 }
36320
36321
36322 SWIGINTERN PyObject *_wrap_Window_ScrollPages(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 *) "pages", NULL
36335 };
36336
36337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",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_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
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_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36346 }
36347 arg2 = static_cast< int >(val2);
36348 {
36349 PyThreadState* __tstate = wxPyBeginAllowThreads();
36350 result = (bool)(arg1)->ScrollPages(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_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36364 PyObject *resultobj = 0;
36365 wxWindow *arg1 = (wxWindow *) 0 ;
36366 bool result;
36367 void *argp1 = 0 ;
36368 int res1 = 0 ;
36369 PyObject *swig_obj[1] ;
36370
36371 if (!args) SWIG_fail;
36372 swig_obj[0] = args;
36373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36374 if (!SWIG_IsOK(res1)) {
36375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36376 }
36377 arg1 = reinterpret_cast< wxWindow * >(argp1);
36378 {
36379 PyThreadState* __tstate = wxPyBeginAllowThreads();
36380 result = (bool)(arg1)->LineUp();
36381 wxPyEndAllowThreads(__tstate);
36382 if (PyErr_Occurred()) SWIG_fail;
36383 }
36384 {
36385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36386 }
36387 return resultobj;
36388 fail:
36389 return NULL;
36390 }
36391
36392
36393 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36394 PyObject *resultobj = 0;
36395 wxWindow *arg1 = (wxWindow *) 0 ;
36396 bool result;
36397 void *argp1 = 0 ;
36398 int res1 = 0 ;
36399 PyObject *swig_obj[1] ;
36400
36401 if (!args) SWIG_fail;
36402 swig_obj[0] = args;
36403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36404 if (!SWIG_IsOK(res1)) {
36405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36406 }
36407 arg1 = reinterpret_cast< wxWindow * >(argp1);
36408 {
36409 PyThreadState* __tstate = wxPyBeginAllowThreads();
36410 result = (bool)(arg1)->LineDown();
36411 wxPyEndAllowThreads(__tstate);
36412 if (PyErr_Occurred()) SWIG_fail;
36413 }
36414 {
36415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36416 }
36417 return resultobj;
36418 fail:
36419 return NULL;
36420 }
36421
36422
36423 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36424 PyObject *resultobj = 0;
36425 wxWindow *arg1 = (wxWindow *) 0 ;
36426 bool result;
36427 void *argp1 = 0 ;
36428 int res1 = 0 ;
36429 PyObject *swig_obj[1] ;
36430
36431 if (!args) SWIG_fail;
36432 swig_obj[0] = args;
36433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36434 if (!SWIG_IsOK(res1)) {
36435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36436 }
36437 arg1 = reinterpret_cast< wxWindow * >(argp1);
36438 {
36439 PyThreadState* __tstate = wxPyBeginAllowThreads();
36440 result = (bool)(arg1)->PageUp();
36441 wxPyEndAllowThreads(__tstate);
36442 if (PyErr_Occurred()) SWIG_fail;
36443 }
36444 {
36445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36446 }
36447 return resultobj;
36448 fail:
36449 return NULL;
36450 }
36451
36452
36453 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36454 PyObject *resultobj = 0;
36455 wxWindow *arg1 = (wxWindow *) 0 ;
36456 bool result;
36457 void *argp1 = 0 ;
36458 int res1 = 0 ;
36459 PyObject *swig_obj[1] ;
36460
36461 if (!args) SWIG_fail;
36462 swig_obj[0] = args;
36463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36464 if (!SWIG_IsOK(res1)) {
36465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36466 }
36467 arg1 = reinterpret_cast< wxWindow * >(argp1);
36468 {
36469 PyThreadState* __tstate = wxPyBeginAllowThreads();
36470 result = (bool)(arg1)->PageDown();
36471 wxPyEndAllowThreads(__tstate);
36472 if (PyErr_Occurred()) SWIG_fail;
36473 }
36474 {
36475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36476 }
36477 return resultobj;
36478 fail:
36479 return NULL;
36480 }
36481
36482
36483 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36484 PyObject *resultobj = 0;
36485 wxWindow *arg1 = (wxWindow *) 0 ;
36486 wxString *arg2 = 0 ;
36487 void *argp1 = 0 ;
36488 int res1 = 0 ;
36489 bool temp2 = false ;
36490 PyObject * obj0 = 0 ;
36491 PyObject * obj1 = 0 ;
36492 char * kwnames[] = {
36493 (char *) "self",(char *) "text", NULL
36494 };
36495
36496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36498 if (!SWIG_IsOK(res1)) {
36499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36500 }
36501 arg1 = reinterpret_cast< wxWindow * >(argp1);
36502 {
36503 arg2 = wxString_in_helper(obj1);
36504 if (arg2 == NULL) SWIG_fail;
36505 temp2 = true;
36506 }
36507 {
36508 PyThreadState* __tstate = wxPyBeginAllowThreads();
36509 (arg1)->SetHelpText((wxString const &)*arg2);
36510 wxPyEndAllowThreads(__tstate);
36511 if (PyErr_Occurred()) SWIG_fail;
36512 }
36513 resultobj = SWIG_Py_Void();
36514 {
36515 if (temp2)
36516 delete arg2;
36517 }
36518 return resultobj;
36519 fail:
36520 {
36521 if (temp2)
36522 delete arg2;
36523 }
36524 return NULL;
36525 }
36526
36527
36528 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36529 PyObject *resultobj = 0;
36530 wxWindow *arg1 = (wxWindow *) 0 ;
36531 wxString *arg2 = 0 ;
36532 void *argp1 = 0 ;
36533 int res1 = 0 ;
36534 bool temp2 = false ;
36535 PyObject * obj0 = 0 ;
36536 PyObject * obj1 = 0 ;
36537 char * kwnames[] = {
36538 (char *) "self",(char *) "text", NULL
36539 };
36540
36541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36543 if (!SWIG_IsOK(res1)) {
36544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36545 }
36546 arg1 = reinterpret_cast< wxWindow * >(argp1);
36547 {
36548 arg2 = wxString_in_helper(obj1);
36549 if (arg2 == NULL) SWIG_fail;
36550 temp2 = true;
36551 }
36552 {
36553 PyThreadState* __tstate = wxPyBeginAllowThreads();
36554 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36555 wxPyEndAllowThreads(__tstate);
36556 if (PyErr_Occurred()) SWIG_fail;
36557 }
36558 resultobj = SWIG_Py_Void();
36559 {
36560 if (temp2)
36561 delete arg2;
36562 }
36563 return resultobj;
36564 fail:
36565 {
36566 if (temp2)
36567 delete arg2;
36568 }
36569 return NULL;
36570 }
36571
36572
36573 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36574 PyObject *resultobj = 0;
36575 wxWindow *arg1 = (wxWindow *) 0 ;
36576 wxString result;
36577 void *argp1 = 0 ;
36578 int res1 = 0 ;
36579 PyObject *swig_obj[1] ;
36580
36581 if (!args) SWIG_fail;
36582 swig_obj[0] = args;
36583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36584 if (!SWIG_IsOK(res1)) {
36585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36586 }
36587 arg1 = reinterpret_cast< wxWindow * >(argp1);
36588 {
36589 PyThreadState* __tstate = wxPyBeginAllowThreads();
36590 result = ((wxWindow const *)arg1)->GetHelpText();
36591 wxPyEndAllowThreads(__tstate);
36592 if (PyErr_Occurred()) SWIG_fail;
36593 }
36594 {
36595 #if wxUSE_UNICODE
36596 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36597 #else
36598 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36599 #endif
36600 }
36601 return resultobj;
36602 fail:
36603 return NULL;
36604 }
36605
36606
36607 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36608 PyObject *resultobj = 0;
36609 wxWindow *arg1 = (wxWindow *) 0 ;
36610 wxString *arg2 = 0 ;
36611 void *argp1 = 0 ;
36612 int res1 = 0 ;
36613 bool temp2 = false ;
36614 PyObject * obj0 = 0 ;
36615 PyObject * obj1 = 0 ;
36616 char * kwnames[] = {
36617 (char *) "self",(char *) "tip", NULL
36618 };
36619
36620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36622 if (!SWIG_IsOK(res1)) {
36623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36624 }
36625 arg1 = reinterpret_cast< wxWindow * >(argp1);
36626 {
36627 arg2 = wxString_in_helper(obj1);
36628 if (arg2 == NULL) SWIG_fail;
36629 temp2 = true;
36630 }
36631 {
36632 PyThreadState* __tstate = wxPyBeginAllowThreads();
36633 (arg1)->SetToolTip((wxString const &)*arg2);
36634 wxPyEndAllowThreads(__tstate);
36635 if (PyErr_Occurred()) SWIG_fail;
36636 }
36637 resultobj = SWIG_Py_Void();
36638 {
36639 if (temp2)
36640 delete arg2;
36641 }
36642 return resultobj;
36643 fail:
36644 {
36645 if (temp2)
36646 delete arg2;
36647 }
36648 return NULL;
36649 }
36650
36651
36652 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36653 PyObject *resultobj = 0;
36654 wxWindow *arg1 = (wxWindow *) 0 ;
36655 wxToolTip *arg2 = (wxToolTip *) 0 ;
36656 void *argp1 = 0 ;
36657 int res1 = 0 ;
36658 int res2 = 0 ;
36659 PyObject * obj0 = 0 ;
36660 PyObject * obj1 = 0 ;
36661 char * kwnames[] = {
36662 (char *) "self",(char *) "tip", NULL
36663 };
36664
36665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36667 if (!SWIG_IsOK(res1)) {
36668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36669 }
36670 arg1 = reinterpret_cast< wxWindow * >(argp1);
36671 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36672 if (!SWIG_IsOK(res2)) {
36673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36674 }
36675 {
36676 PyThreadState* __tstate = wxPyBeginAllowThreads();
36677 (arg1)->SetToolTip(arg2);
36678 wxPyEndAllowThreads(__tstate);
36679 if (PyErr_Occurred()) SWIG_fail;
36680 }
36681 resultobj = SWIG_Py_Void();
36682 return resultobj;
36683 fail:
36684 return NULL;
36685 }
36686
36687
36688 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36689 PyObject *resultobj = 0;
36690 wxWindow *arg1 = (wxWindow *) 0 ;
36691 wxToolTip *result = 0 ;
36692 void *argp1 = 0 ;
36693 int res1 = 0 ;
36694 PyObject *swig_obj[1] ;
36695
36696 if (!args) SWIG_fail;
36697 swig_obj[0] = args;
36698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36699 if (!SWIG_IsOK(res1)) {
36700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36701 }
36702 arg1 = reinterpret_cast< wxWindow * >(argp1);
36703 {
36704 PyThreadState* __tstate = wxPyBeginAllowThreads();
36705 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36706 wxPyEndAllowThreads(__tstate);
36707 if (PyErr_Occurred()) SWIG_fail;
36708 }
36709 {
36710 resultobj = wxPyMake_wxObject(result, (bool)0);
36711 }
36712 return resultobj;
36713 fail:
36714 return NULL;
36715 }
36716
36717
36718 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36719 PyObject *resultobj = 0;
36720 wxWindow *arg1 = (wxWindow *) 0 ;
36721 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36722 void *argp1 = 0 ;
36723 int res1 = 0 ;
36724 int res2 = 0 ;
36725 PyObject * obj0 = 0 ;
36726 PyObject * obj1 = 0 ;
36727 char * kwnames[] = {
36728 (char *) "self",(char *) "dropTarget", NULL
36729 };
36730
36731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36733 if (!SWIG_IsOK(res1)) {
36734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36735 }
36736 arg1 = reinterpret_cast< wxWindow * >(argp1);
36737 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36738 if (!SWIG_IsOK(res2)) {
36739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36740 }
36741 {
36742 PyThreadState* __tstate = wxPyBeginAllowThreads();
36743 (arg1)->SetDropTarget(arg2);
36744 wxPyEndAllowThreads(__tstate);
36745 if (PyErr_Occurred()) SWIG_fail;
36746 }
36747 resultobj = SWIG_Py_Void();
36748 return resultobj;
36749 fail:
36750 return NULL;
36751 }
36752
36753
36754 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36755 PyObject *resultobj = 0;
36756 wxWindow *arg1 = (wxWindow *) 0 ;
36757 wxPyDropTarget *result = 0 ;
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_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36767 }
36768 arg1 = reinterpret_cast< wxWindow * >(argp1);
36769 {
36770 PyThreadState* __tstate = wxPyBeginAllowThreads();
36771 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36772 wxPyEndAllowThreads(__tstate);
36773 if (PyErr_Occurred()) SWIG_fail;
36774 }
36775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36776 return resultobj;
36777 fail:
36778 return NULL;
36779 }
36780
36781
36782 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36783 PyObject *resultobj = 0;
36784 wxWindow *arg1 = (wxWindow *) 0 ;
36785 bool arg2 ;
36786 void *argp1 = 0 ;
36787 int res1 = 0 ;
36788 bool val2 ;
36789 int ecode2 = 0 ;
36790 PyObject * obj0 = 0 ;
36791 PyObject * obj1 = 0 ;
36792 char * kwnames[] = {
36793 (char *) "self",(char *) "accept", NULL
36794 };
36795
36796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
36797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36798 if (!SWIG_IsOK(res1)) {
36799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
36800 }
36801 arg1 = reinterpret_cast< wxWindow * >(argp1);
36802 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36803 if (!SWIG_IsOK(ecode2)) {
36804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
36805 }
36806 arg2 = static_cast< bool >(val2);
36807 {
36808 PyThreadState* __tstate = wxPyBeginAllowThreads();
36809 wxWindow_DragAcceptFiles(arg1,arg2);
36810 wxPyEndAllowThreads(__tstate);
36811 if (PyErr_Occurred()) SWIG_fail;
36812 }
36813 resultobj = SWIG_Py_Void();
36814 return resultobj;
36815 fail:
36816 return NULL;
36817 }
36818
36819
36820 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36821 PyObject *resultobj = 0;
36822 wxWindow *arg1 = (wxWindow *) 0 ;
36823 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
36824 void *argp1 = 0 ;
36825 int res1 = 0 ;
36826 int res2 = 0 ;
36827 PyObject * obj0 = 0 ;
36828 PyObject * obj1 = 0 ;
36829 char * kwnames[] = {
36830 (char *) "self",(char *) "constraints", NULL
36831 };
36832
36833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
36834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36835 if (!SWIG_IsOK(res1)) {
36836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
36837 }
36838 arg1 = reinterpret_cast< wxWindow * >(argp1);
36839 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
36840 if (!SWIG_IsOK(res2)) {
36841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
36842 }
36843 {
36844 PyThreadState* __tstate = wxPyBeginAllowThreads();
36845 (arg1)->SetConstraints(arg2);
36846 wxPyEndAllowThreads(__tstate);
36847 if (PyErr_Occurred()) SWIG_fail;
36848 }
36849 resultobj = SWIG_Py_Void();
36850 return resultobj;
36851 fail:
36852 return NULL;
36853 }
36854
36855
36856 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36857 PyObject *resultobj = 0;
36858 wxWindow *arg1 = (wxWindow *) 0 ;
36859 wxLayoutConstraints *result = 0 ;
36860 void *argp1 = 0 ;
36861 int res1 = 0 ;
36862 PyObject *swig_obj[1] ;
36863
36864 if (!args) SWIG_fail;
36865 swig_obj[0] = args;
36866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36867 if (!SWIG_IsOK(res1)) {
36868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
36869 }
36870 arg1 = reinterpret_cast< wxWindow * >(argp1);
36871 {
36872 PyThreadState* __tstate = wxPyBeginAllowThreads();
36873 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
36874 wxPyEndAllowThreads(__tstate);
36875 if (PyErr_Occurred()) SWIG_fail;
36876 }
36877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
36878 return resultobj;
36879 fail:
36880 return NULL;
36881 }
36882
36883
36884 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36885 PyObject *resultobj = 0;
36886 wxWindow *arg1 = (wxWindow *) 0 ;
36887 bool arg2 ;
36888 void *argp1 = 0 ;
36889 int res1 = 0 ;
36890 bool val2 ;
36891 int ecode2 = 0 ;
36892 PyObject * obj0 = 0 ;
36893 PyObject * obj1 = 0 ;
36894 char * kwnames[] = {
36895 (char *) "self",(char *) "autoLayout", NULL
36896 };
36897
36898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
36899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36900 if (!SWIG_IsOK(res1)) {
36901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
36902 }
36903 arg1 = reinterpret_cast< wxWindow * >(argp1);
36904 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36905 if (!SWIG_IsOK(ecode2)) {
36906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
36907 }
36908 arg2 = static_cast< bool >(val2);
36909 {
36910 PyThreadState* __tstate = wxPyBeginAllowThreads();
36911 (arg1)->SetAutoLayout(arg2);
36912 wxPyEndAllowThreads(__tstate);
36913 if (PyErr_Occurred()) SWIG_fail;
36914 }
36915 resultobj = SWIG_Py_Void();
36916 return resultobj;
36917 fail:
36918 return NULL;
36919 }
36920
36921
36922 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36923 PyObject *resultobj = 0;
36924 wxWindow *arg1 = (wxWindow *) 0 ;
36925 bool result;
36926 void *argp1 = 0 ;
36927 int res1 = 0 ;
36928 PyObject *swig_obj[1] ;
36929
36930 if (!args) SWIG_fail;
36931 swig_obj[0] = args;
36932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36933 if (!SWIG_IsOK(res1)) {
36934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
36935 }
36936 arg1 = reinterpret_cast< wxWindow * >(argp1);
36937 {
36938 PyThreadState* __tstate = wxPyBeginAllowThreads();
36939 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
36940 wxPyEndAllowThreads(__tstate);
36941 if (PyErr_Occurred()) SWIG_fail;
36942 }
36943 {
36944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36945 }
36946 return resultobj;
36947 fail:
36948 return NULL;
36949 }
36950
36951
36952 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36953 PyObject *resultobj = 0;
36954 wxWindow *arg1 = (wxWindow *) 0 ;
36955 bool result;
36956 void *argp1 = 0 ;
36957 int res1 = 0 ;
36958 PyObject *swig_obj[1] ;
36959
36960 if (!args) SWIG_fail;
36961 swig_obj[0] = args;
36962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36963 if (!SWIG_IsOK(res1)) {
36964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
36965 }
36966 arg1 = reinterpret_cast< wxWindow * >(argp1);
36967 {
36968 PyThreadState* __tstate = wxPyBeginAllowThreads();
36969 result = (bool)(arg1)->Layout();
36970 wxPyEndAllowThreads(__tstate);
36971 if (PyErr_Occurred()) SWIG_fail;
36972 }
36973 {
36974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36975 }
36976 return resultobj;
36977 fail:
36978 return NULL;
36979 }
36980
36981
36982 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36983 PyObject *resultobj = 0;
36984 wxWindow *arg1 = (wxWindow *) 0 ;
36985 wxSizer *arg2 = (wxSizer *) 0 ;
36986 bool arg3 = (bool) true ;
36987 void *argp1 = 0 ;
36988 int res1 = 0 ;
36989 int res2 = 0 ;
36990 bool val3 ;
36991 int ecode3 = 0 ;
36992 PyObject * obj0 = 0 ;
36993 PyObject * obj1 = 0 ;
36994 PyObject * obj2 = 0 ;
36995 char * kwnames[] = {
36996 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
36997 };
36998
36999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37001 if (!SWIG_IsOK(res1)) {
37002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37003 }
37004 arg1 = reinterpret_cast< wxWindow * >(argp1);
37005 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37006 if (!SWIG_IsOK(res2)) {
37007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37008 }
37009 if (obj2) {
37010 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37011 if (!SWIG_IsOK(ecode3)) {
37012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37013 }
37014 arg3 = static_cast< bool >(val3);
37015 }
37016 {
37017 PyThreadState* __tstate = wxPyBeginAllowThreads();
37018 (arg1)->SetSizer(arg2,arg3);
37019 wxPyEndAllowThreads(__tstate);
37020 if (PyErr_Occurred()) SWIG_fail;
37021 }
37022 resultobj = SWIG_Py_Void();
37023 return resultobj;
37024 fail:
37025 return NULL;
37026 }
37027
37028
37029 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37030 PyObject *resultobj = 0;
37031 wxWindow *arg1 = (wxWindow *) 0 ;
37032 wxSizer *arg2 = (wxSizer *) 0 ;
37033 bool arg3 = (bool) true ;
37034 void *argp1 = 0 ;
37035 int res1 = 0 ;
37036 int res2 = 0 ;
37037 bool val3 ;
37038 int ecode3 = 0 ;
37039 PyObject * obj0 = 0 ;
37040 PyObject * obj1 = 0 ;
37041 PyObject * obj2 = 0 ;
37042 char * kwnames[] = {
37043 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37044 };
37045
37046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37048 if (!SWIG_IsOK(res1)) {
37049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37050 }
37051 arg1 = reinterpret_cast< wxWindow * >(argp1);
37052 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37053 if (!SWIG_IsOK(res2)) {
37054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37055 }
37056 if (obj2) {
37057 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37058 if (!SWIG_IsOK(ecode3)) {
37059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37060 }
37061 arg3 = static_cast< bool >(val3);
37062 }
37063 {
37064 PyThreadState* __tstate = wxPyBeginAllowThreads();
37065 (arg1)->SetSizerAndFit(arg2,arg3);
37066 wxPyEndAllowThreads(__tstate);
37067 if (PyErr_Occurred()) SWIG_fail;
37068 }
37069 resultobj = SWIG_Py_Void();
37070 return resultobj;
37071 fail:
37072 return NULL;
37073 }
37074
37075
37076 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37077 PyObject *resultobj = 0;
37078 wxWindow *arg1 = (wxWindow *) 0 ;
37079 wxSizer *result = 0 ;
37080 void *argp1 = 0 ;
37081 int res1 = 0 ;
37082 PyObject *swig_obj[1] ;
37083
37084 if (!args) SWIG_fail;
37085 swig_obj[0] = args;
37086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37087 if (!SWIG_IsOK(res1)) {
37088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37089 }
37090 arg1 = reinterpret_cast< wxWindow * >(argp1);
37091 {
37092 PyThreadState* __tstate = wxPyBeginAllowThreads();
37093 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37094 wxPyEndAllowThreads(__tstate);
37095 if (PyErr_Occurred()) SWIG_fail;
37096 }
37097 {
37098 resultobj = wxPyMake_wxObject(result, (bool)0);
37099 }
37100 return resultobj;
37101 fail:
37102 return NULL;
37103 }
37104
37105
37106 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37107 PyObject *resultobj = 0;
37108 wxWindow *arg1 = (wxWindow *) 0 ;
37109 wxSizer *arg2 = (wxSizer *) 0 ;
37110 void *argp1 = 0 ;
37111 int res1 = 0 ;
37112 void *argp2 = 0 ;
37113 int res2 = 0 ;
37114 PyObject * obj0 = 0 ;
37115 PyObject * obj1 = 0 ;
37116 char * kwnames[] = {
37117 (char *) "self",(char *) "sizer", NULL
37118 };
37119
37120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37122 if (!SWIG_IsOK(res1)) {
37123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37124 }
37125 arg1 = reinterpret_cast< wxWindow * >(argp1);
37126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37127 if (!SWIG_IsOK(res2)) {
37128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37129 }
37130 arg2 = reinterpret_cast< wxSizer * >(argp2);
37131 {
37132 PyThreadState* __tstate = wxPyBeginAllowThreads();
37133 (arg1)->SetContainingSizer(arg2);
37134 wxPyEndAllowThreads(__tstate);
37135 if (PyErr_Occurred()) SWIG_fail;
37136 }
37137 resultobj = SWIG_Py_Void();
37138 return resultobj;
37139 fail:
37140 return NULL;
37141 }
37142
37143
37144 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37145 PyObject *resultobj = 0;
37146 wxWindow *arg1 = (wxWindow *) 0 ;
37147 wxSizer *result = 0 ;
37148 void *argp1 = 0 ;
37149 int res1 = 0 ;
37150 PyObject *swig_obj[1] ;
37151
37152 if (!args) SWIG_fail;
37153 swig_obj[0] = args;
37154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37155 if (!SWIG_IsOK(res1)) {
37156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37157 }
37158 arg1 = reinterpret_cast< wxWindow * >(argp1);
37159 {
37160 PyThreadState* __tstate = wxPyBeginAllowThreads();
37161 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37162 wxPyEndAllowThreads(__tstate);
37163 if (PyErr_Occurred()) SWIG_fail;
37164 }
37165 {
37166 resultobj = wxPyMake_wxObject(result, (bool)0);
37167 }
37168 return resultobj;
37169 fail:
37170 return NULL;
37171 }
37172
37173
37174 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37175 PyObject *resultobj = 0;
37176 wxWindow *arg1 = (wxWindow *) 0 ;
37177 void *argp1 = 0 ;
37178 int res1 = 0 ;
37179 PyObject *swig_obj[1] ;
37180
37181 if (!args) SWIG_fail;
37182 swig_obj[0] = args;
37183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37184 if (!SWIG_IsOK(res1)) {
37185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37186 }
37187 arg1 = reinterpret_cast< wxWindow * >(argp1);
37188 {
37189 PyThreadState* __tstate = wxPyBeginAllowThreads();
37190 (arg1)->InheritAttributes();
37191 wxPyEndAllowThreads(__tstate);
37192 if (PyErr_Occurred()) SWIG_fail;
37193 }
37194 resultobj = SWIG_Py_Void();
37195 return resultobj;
37196 fail:
37197 return NULL;
37198 }
37199
37200
37201 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37202 PyObject *resultobj = 0;
37203 wxWindow *arg1 = (wxWindow *) 0 ;
37204 bool result;
37205 void *argp1 = 0 ;
37206 int res1 = 0 ;
37207 PyObject *swig_obj[1] ;
37208
37209 if (!args) SWIG_fail;
37210 swig_obj[0] = args;
37211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37212 if (!SWIG_IsOK(res1)) {
37213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37214 }
37215 arg1 = reinterpret_cast< wxWindow * >(argp1);
37216 {
37217 PyThreadState* __tstate = wxPyBeginAllowThreads();
37218 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37219 wxPyEndAllowThreads(__tstate);
37220 if (PyErr_Occurred()) SWIG_fail;
37221 }
37222 {
37223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37224 }
37225 return resultobj;
37226 fail:
37227 return NULL;
37228 }
37229
37230
37231 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37232 PyObject *obj;
37233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37234 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37235 return SWIG_Py_Void();
37236 }
37237
37238 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37239 return SWIG_Python_InitShadowInstance(args);
37240 }
37241
37242 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37243 PyObject *resultobj = 0;
37244 long arg1 ;
37245 wxWindow *arg2 = (wxWindow *) NULL ;
37246 wxWindow *result = 0 ;
37247 long val1 ;
37248 int ecode1 = 0 ;
37249 void *argp2 = 0 ;
37250 int res2 = 0 ;
37251 PyObject * obj0 = 0 ;
37252 PyObject * obj1 = 0 ;
37253 char * kwnames[] = {
37254 (char *) "id",(char *) "parent", NULL
37255 };
37256
37257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37258 ecode1 = SWIG_AsVal_long(obj0, &val1);
37259 if (!SWIG_IsOK(ecode1)) {
37260 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37261 }
37262 arg1 = static_cast< long >(val1);
37263 if (obj1) {
37264 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37265 if (!SWIG_IsOK(res2)) {
37266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37267 }
37268 arg2 = reinterpret_cast< wxWindow * >(argp2);
37269 }
37270 {
37271 if (!wxPyCheckForApp()) SWIG_fail;
37272 PyThreadState* __tstate = wxPyBeginAllowThreads();
37273 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37274 wxPyEndAllowThreads(__tstate);
37275 if (PyErr_Occurred()) SWIG_fail;
37276 }
37277 {
37278 resultobj = wxPyMake_wxObject(result, 0);
37279 }
37280 return resultobj;
37281 fail:
37282 return NULL;
37283 }
37284
37285
37286 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37287 PyObject *resultobj = 0;
37288 wxString *arg1 = 0 ;
37289 wxWindow *arg2 = (wxWindow *) NULL ;
37290 wxWindow *result = 0 ;
37291 bool temp1 = false ;
37292 void *argp2 = 0 ;
37293 int res2 = 0 ;
37294 PyObject * obj0 = 0 ;
37295 PyObject * obj1 = 0 ;
37296 char * kwnames[] = {
37297 (char *) "name",(char *) "parent", NULL
37298 };
37299
37300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37301 {
37302 arg1 = wxString_in_helper(obj0);
37303 if (arg1 == NULL) SWIG_fail;
37304 temp1 = true;
37305 }
37306 if (obj1) {
37307 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37308 if (!SWIG_IsOK(res2)) {
37309 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37310 }
37311 arg2 = reinterpret_cast< wxWindow * >(argp2);
37312 }
37313 {
37314 if (!wxPyCheckForApp()) SWIG_fail;
37315 PyThreadState* __tstate = wxPyBeginAllowThreads();
37316 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37317 wxPyEndAllowThreads(__tstate);
37318 if (PyErr_Occurred()) SWIG_fail;
37319 }
37320 {
37321 resultobj = wxPyMake_wxObject(result, 0);
37322 }
37323 {
37324 if (temp1)
37325 delete arg1;
37326 }
37327 return resultobj;
37328 fail:
37329 {
37330 if (temp1)
37331 delete arg1;
37332 }
37333 return NULL;
37334 }
37335
37336
37337 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37338 PyObject *resultobj = 0;
37339 wxString *arg1 = 0 ;
37340 wxWindow *arg2 = (wxWindow *) NULL ;
37341 wxWindow *result = 0 ;
37342 bool temp1 = false ;
37343 void *argp2 = 0 ;
37344 int res2 = 0 ;
37345 PyObject * obj0 = 0 ;
37346 PyObject * obj1 = 0 ;
37347 char * kwnames[] = {
37348 (char *) "label",(char *) "parent", NULL
37349 };
37350
37351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37352 {
37353 arg1 = wxString_in_helper(obj0);
37354 if (arg1 == NULL) SWIG_fail;
37355 temp1 = true;
37356 }
37357 if (obj1) {
37358 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37359 if (!SWIG_IsOK(res2)) {
37360 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37361 }
37362 arg2 = reinterpret_cast< wxWindow * >(argp2);
37363 }
37364 {
37365 if (!wxPyCheckForApp()) SWIG_fail;
37366 PyThreadState* __tstate = wxPyBeginAllowThreads();
37367 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37368 wxPyEndAllowThreads(__tstate);
37369 if (PyErr_Occurred()) SWIG_fail;
37370 }
37371 {
37372 resultobj = wxPyMake_wxObject(result, 0);
37373 }
37374 {
37375 if (temp1)
37376 delete arg1;
37377 }
37378 return resultobj;
37379 fail:
37380 {
37381 if (temp1)
37382 delete arg1;
37383 }
37384 return NULL;
37385 }
37386
37387
37388 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37389 PyObject *resultobj = 0;
37390 wxWindow *arg1 = (wxWindow *) 0 ;
37391 unsigned long arg2 ;
37392 wxWindow *result = 0 ;
37393 void *argp1 = 0 ;
37394 int res1 = 0 ;
37395 unsigned long val2 ;
37396 int ecode2 = 0 ;
37397 PyObject * obj0 = 0 ;
37398 PyObject * obj1 = 0 ;
37399 char * kwnames[] = {
37400 (char *) "parent",(char *) "_hWnd", NULL
37401 };
37402
37403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37405 if (!SWIG_IsOK(res1)) {
37406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37407 }
37408 arg1 = reinterpret_cast< wxWindow * >(argp1);
37409 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37410 if (!SWIG_IsOK(ecode2)) {
37411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37412 }
37413 arg2 = static_cast< unsigned long >(val2);
37414 {
37415 PyThreadState* __tstate = wxPyBeginAllowThreads();
37416 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37417 wxPyEndAllowThreads(__tstate);
37418 if (PyErr_Occurred()) SWIG_fail;
37419 }
37420 {
37421 resultobj = wxPyMake_wxObject(result, 0);
37422 }
37423 return resultobj;
37424 fail:
37425 return NULL;
37426 }
37427
37428
37429 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37430 PyObject *resultobj = 0;
37431 PyObject *result = 0 ;
37432
37433 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37434 {
37435 PyThreadState* __tstate = wxPyBeginAllowThreads();
37436 result = (PyObject *)GetTopLevelWindows();
37437 wxPyEndAllowThreads(__tstate);
37438 if (PyErr_Occurred()) SWIG_fail;
37439 }
37440 resultobj = result;
37441 return resultobj;
37442 fail:
37443 return NULL;
37444 }
37445
37446
37447 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37448 PyObject *resultobj = 0;
37449 wxValidator *result = 0 ;
37450
37451 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37452 {
37453 PyThreadState* __tstate = wxPyBeginAllowThreads();
37454 result = (wxValidator *)new wxValidator();
37455 wxPyEndAllowThreads(__tstate);
37456 if (PyErr_Occurred()) SWIG_fail;
37457 }
37458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37459 return resultobj;
37460 fail:
37461 return NULL;
37462 }
37463
37464
37465 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37466 PyObject *resultobj = 0;
37467 wxValidator *arg1 = (wxValidator *) 0 ;
37468 wxValidator *result = 0 ;
37469 void *argp1 = 0 ;
37470 int res1 = 0 ;
37471 PyObject *swig_obj[1] ;
37472
37473 if (!args) SWIG_fail;
37474 swig_obj[0] = args;
37475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37476 if (!SWIG_IsOK(res1)) {
37477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37478 }
37479 arg1 = reinterpret_cast< wxValidator * >(argp1);
37480 {
37481 PyThreadState* __tstate = wxPyBeginAllowThreads();
37482 result = (wxValidator *)(arg1)->Clone();
37483 wxPyEndAllowThreads(__tstate);
37484 if (PyErr_Occurred()) SWIG_fail;
37485 }
37486 {
37487 resultobj = wxPyMake_wxObject(result, 0);
37488 }
37489 return resultobj;
37490 fail:
37491 return NULL;
37492 }
37493
37494
37495 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37496 PyObject *resultobj = 0;
37497 wxValidator *arg1 = (wxValidator *) 0 ;
37498 wxWindow *arg2 = (wxWindow *) 0 ;
37499 bool result;
37500 void *argp1 = 0 ;
37501 int res1 = 0 ;
37502 void *argp2 = 0 ;
37503 int res2 = 0 ;
37504 PyObject * obj0 = 0 ;
37505 PyObject * obj1 = 0 ;
37506 char * kwnames[] = {
37507 (char *) "self",(char *) "parent", NULL
37508 };
37509
37510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37512 if (!SWIG_IsOK(res1)) {
37513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37514 }
37515 arg1 = reinterpret_cast< wxValidator * >(argp1);
37516 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37517 if (!SWIG_IsOK(res2)) {
37518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37519 }
37520 arg2 = reinterpret_cast< wxWindow * >(argp2);
37521 {
37522 PyThreadState* __tstate = wxPyBeginAllowThreads();
37523 result = (bool)(arg1)->Validate(arg2);
37524 wxPyEndAllowThreads(__tstate);
37525 if (PyErr_Occurred()) SWIG_fail;
37526 }
37527 {
37528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37529 }
37530 return resultobj;
37531 fail:
37532 return NULL;
37533 }
37534
37535
37536 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37537 PyObject *resultobj = 0;
37538 wxValidator *arg1 = (wxValidator *) 0 ;
37539 bool result;
37540 void *argp1 = 0 ;
37541 int res1 = 0 ;
37542 PyObject *swig_obj[1] ;
37543
37544 if (!args) SWIG_fail;
37545 swig_obj[0] = args;
37546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37547 if (!SWIG_IsOK(res1)) {
37548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37549 }
37550 arg1 = reinterpret_cast< wxValidator * >(argp1);
37551 {
37552 PyThreadState* __tstate = wxPyBeginAllowThreads();
37553 result = (bool)(arg1)->TransferToWindow();
37554 wxPyEndAllowThreads(__tstate);
37555 if (PyErr_Occurred()) SWIG_fail;
37556 }
37557 {
37558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37559 }
37560 return resultobj;
37561 fail:
37562 return NULL;
37563 }
37564
37565
37566 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37567 PyObject *resultobj = 0;
37568 wxValidator *arg1 = (wxValidator *) 0 ;
37569 bool result;
37570 void *argp1 = 0 ;
37571 int res1 = 0 ;
37572 PyObject *swig_obj[1] ;
37573
37574 if (!args) SWIG_fail;
37575 swig_obj[0] = args;
37576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37577 if (!SWIG_IsOK(res1)) {
37578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37579 }
37580 arg1 = reinterpret_cast< wxValidator * >(argp1);
37581 {
37582 PyThreadState* __tstate = wxPyBeginAllowThreads();
37583 result = (bool)(arg1)->TransferFromWindow();
37584 wxPyEndAllowThreads(__tstate);
37585 if (PyErr_Occurred()) SWIG_fail;
37586 }
37587 {
37588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37589 }
37590 return resultobj;
37591 fail:
37592 return NULL;
37593 }
37594
37595
37596 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37597 PyObject *resultobj = 0;
37598 wxValidator *arg1 = (wxValidator *) 0 ;
37599 wxWindow *result = 0 ;
37600 void *argp1 = 0 ;
37601 int res1 = 0 ;
37602 PyObject *swig_obj[1] ;
37603
37604 if (!args) SWIG_fail;
37605 swig_obj[0] = args;
37606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37607 if (!SWIG_IsOK(res1)) {
37608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37609 }
37610 arg1 = reinterpret_cast< wxValidator * >(argp1);
37611 {
37612 PyThreadState* __tstate = wxPyBeginAllowThreads();
37613 result = (wxWindow *)(arg1)->GetWindow();
37614 wxPyEndAllowThreads(__tstate);
37615 if (PyErr_Occurred()) SWIG_fail;
37616 }
37617 {
37618 resultobj = wxPyMake_wxObject(result, 0);
37619 }
37620 return resultobj;
37621 fail:
37622 return NULL;
37623 }
37624
37625
37626 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37627 PyObject *resultobj = 0;
37628 wxValidator *arg1 = (wxValidator *) 0 ;
37629 wxWindow *arg2 = (wxWindow *) 0 ;
37630 void *argp1 = 0 ;
37631 int res1 = 0 ;
37632 void *argp2 = 0 ;
37633 int res2 = 0 ;
37634 PyObject * obj0 = 0 ;
37635 PyObject * obj1 = 0 ;
37636 char * kwnames[] = {
37637 (char *) "self",(char *) "window", NULL
37638 };
37639
37640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37642 if (!SWIG_IsOK(res1)) {
37643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37644 }
37645 arg1 = reinterpret_cast< wxValidator * >(argp1);
37646 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37647 if (!SWIG_IsOK(res2)) {
37648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37649 }
37650 arg2 = reinterpret_cast< wxWindow * >(argp2);
37651 {
37652 PyThreadState* __tstate = wxPyBeginAllowThreads();
37653 (arg1)->SetWindow(arg2);
37654 wxPyEndAllowThreads(__tstate);
37655 if (PyErr_Occurred()) SWIG_fail;
37656 }
37657 resultobj = SWIG_Py_Void();
37658 return resultobj;
37659 fail:
37660 return NULL;
37661 }
37662
37663
37664 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37665 PyObject *resultobj = 0;
37666 bool result;
37667
37668 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37669 {
37670 PyThreadState* __tstate = wxPyBeginAllowThreads();
37671 result = (bool)wxValidator::IsSilent();
37672 wxPyEndAllowThreads(__tstate);
37673 if (PyErr_Occurred()) SWIG_fail;
37674 }
37675 {
37676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37677 }
37678 return resultobj;
37679 fail:
37680 return NULL;
37681 }
37682
37683
37684 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37685 PyObject *resultobj = 0;
37686 int arg1 = (int) true ;
37687 int val1 ;
37688 int ecode1 = 0 ;
37689 PyObject * obj0 = 0 ;
37690 char * kwnames[] = {
37691 (char *) "doIt", NULL
37692 };
37693
37694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37695 if (obj0) {
37696 ecode1 = SWIG_AsVal_int(obj0, &val1);
37697 if (!SWIG_IsOK(ecode1)) {
37698 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37699 }
37700 arg1 = static_cast< int >(val1);
37701 }
37702 {
37703 PyThreadState* __tstate = wxPyBeginAllowThreads();
37704 wxValidator::SetBellOnError(arg1);
37705 wxPyEndAllowThreads(__tstate);
37706 if (PyErr_Occurred()) SWIG_fail;
37707 }
37708 resultobj = SWIG_Py_Void();
37709 return resultobj;
37710 fail:
37711 return NULL;
37712 }
37713
37714
37715 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37716 PyObject *obj;
37717 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37718 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37719 return SWIG_Py_Void();
37720 }
37721
37722 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37723 return SWIG_Python_InitShadowInstance(args);
37724 }
37725
37726 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37727 PyObject *resultobj = 0;
37728 wxPyValidator *result = 0 ;
37729
37730 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37731 {
37732 PyThreadState* __tstate = wxPyBeginAllowThreads();
37733 result = (wxPyValidator *)new wxPyValidator();
37734 wxPyEndAllowThreads(__tstate);
37735 if (PyErr_Occurred()) SWIG_fail;
37736 }
37737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37738 return resultobj;
37739 fail:
37740 return NULL;
37741 }
37742
37743
37744 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37745 PyObject *resultobj = 0;
37746 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37747 PyObject *arg2 = (PyObject *) 0 ;
37748 PyObject *arg3 = (PyObject *) 0 ;
37749 int arg4 = (int) true ;
37750 void *argp1 = 0 ;
37751 int res1 = 0 ;
37752 int val4 ;
37753 int ecode4 = 0 ;
37754 PyObject * obj0 = 0 ;
37755 PyObject * obj1 = 0 ;
37756 PyObject * obj2 = 0 ;
37757 PyObject * obj3 = 0 ;
37758 char * kwnames[] = {
37759 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37760 };
37761
37762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37764 if (!SWIG_IsOK(res1)) {
37765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37766 }
37767 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37768 arg2 = obj1;
37769 arg3 = obj2;
37770 if (obj3) {
37771 ecode4 = SWIG_AsVal_int(obj3, &val4);
37772 if (!SWIG_IsOK(ecode4)) {
37773 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37774 }
37775 arg4 = static_cast< int >(val4);
37776 }
37777 {
37778 PyThreadState* __tstate = wxPyBeginAllowThreads();
37779 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37780 wxPyEndAllowThreads(__tstate);
37781 if (PyErr_Occurred()) SWIG_fail;
37782 }
37783 resultobj = SWIG_Py_Void();
37784 return resultobj;
37785 fail:
37786 return NULL;
37787 }
37788
37789
37790 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37791 PyObject *obj;
37792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37793 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
37794 return SWIG_Py_Void();
37795 }
37796
37797 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37798 return SWIG_Python_InitShadowInstance(args);
37799 }
37800
37801 SWIGINTERN int DefaultValidator_set(PyObject *) {
37802 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
37803 return 1;
37804 }
37805
37806
37807 SWIGINTERN PyObject *DefaultValidator_get(void) {
37808 PyObject *pyobj = 0;
37809
37810 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
37811 return pyobj;
37812 }
37813
37814
37815 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37816 PyObject *resultobj = 0;
37817 wxString const &arg1_defvalue = wxPyEmptyString ;
37818 wxString *arg1 = (wxString *) &arg1_defvalue ;
37819 long arg2 = (long) 0 ;
37820 wxMenu *result = 0 ;
37821 bool temp1 = false ;
37822 long val2 ;
37823 int ecode2 = 0 ;
37824 PyObject * obj0 = 0 ;
37825 PyObject * obj1 = 0 ;
37826 char * kwnames[] = {
37827 (char *) "title",(char *) "style", NULL
37828 };
37829
37830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
37831 if (obj0) {
37832 {
37833 arg1 = wxString_in_helper(obj0);
37834 if (arg1 == NULL) SWIG_fail;
37835 temp1 = true;
37836 }
37837 }
37838 if (obj1) {
37839 ecode2 = SWIG_AsVal_long(obj1, &val2);
37840 if (!SWIG_IsOK(ecode2)) {
37841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
37842 }
37843 arg2 = static_cast< long >(val2);
37844 }
37845 {
37846 if (!wxPyCheckForApp()) SWIG_fail;
37847 PyThreadState* __tstate = wxPyBeginAllowThreads();
37848 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
37849 wxPyEndAllowThreads(__tstate);
37850 if (PyErr_Occurred()) SWIG_fail;
37851 }
37852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
37853 {
37854 if (temp1)
37855 delete arg1;
37856 }
37857 return resultobj;
37858 fail:
37859 {
37860 if (temp1)
37861 delete arg1;
37862 }
37863 return NULL;
37864 }
37865
37866
37867 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37868 PyObject *resultobj = 0;
37869 wxMenu *arg1 = (wxMenu *) 0 ;
37870 int arg2 ;
37871 wxString *arg3 = 0 ;
37872 wxString const &arg4_defvalue = wxPyEmptyString ;
37873 wxString *arg4 = (wxString *) &arg4_defvalue ;
37874 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
37875 wxMenuItem *result = 0 ;
37876 void *argp1 = 0 ;
37877 int res1 = 0 ;
37878 int val2 ;
37879 int ecode2 = 0 ;
37880 bool temp3 = false ;
37881 bool temp4 = false ;
37882 int val5 ;
37883 int ecode5 = 0 ;
37884 PyObject * obj0 = 0 ;
37885 PyObject * obj1 = 0 ;
37886 PyObject * obj2 = 0 ;
37887 PyObject * obj3 = 0 ;
37888 PyObject * obj4 = 0 ;
37889 char * kwnames[] = {
37890 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
37891 };
37892
37893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
37895 if (!SWIG_IsOK(res1)) {
37896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
37897 }
37898 arg1 = reinterpret_cast< wxMenu * >(argp1);
37899 ecode2 = SWIG_AsVal_int(obj1, &val2);
37900 if (!SWIG_IsOK(ecode2)) {
37901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
37902 }
37903 arg2 = static_cast< int >(val2);
37904 {
37905 arg3 = wxString_in_helper(obj2);
37906 if (arg3 == NULL) SWIG_fail;
37907 temp3 = true;
37908 }
37909 if (obj3) {
37910 {
37911 arg4 = wxString_in_helper(obj3);
37912 if (arg4 == NULL) SWIG_fail;
37913 temp4 = true;
37914 }
37915 }
37916 if (obj4) {
37917 ecode5 = SWIG_AsVal_int(obj4, &val5);
37918 if (!SWIG_IsOK(ecode5)) {
37919 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
37920 }
37921 arg5 = static_cast< wxItemKind >(val5);
37922 }
37923 {
37924 PyThreadState* __tstate = wxPyBeginAllowThreads();
37925 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
37926 wxPyEndAllowThreads(__tstate);
37927 if (PyErr_Occurred()) SWIG_fail;
37928 }
37929 {
37930 resultobj = wxPyMake_wxObject(result, (bool)0);
37931 }
37932 {
37933 if (temp3)
37934 delete arg3;
37935 }
37936 {
37937 if (temp4)
37938 delete arg4;
37939 }
37940 return resultobj;
37941 fail:
37942 {
37943 if (temp3)
37944 delete arg3;
37945 }
37946 {
37947 if (temp4)
37948 delete arg4;
37949 }
37950 return NULL;
37951 }
37952
37953
37954 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37955 PyObject *resultobj = 0;
37956 wxMenu *arg1 = (wxMenu *) 0 ;
37957 wxMenuItem *result = 0 ;
37958 void *argp1 = 0 ;
37959 int res1 = 0 ;
37960 PyObject *swig_obj[1] ;
37961
37962 if (!args) SWIG_fail;
37963 swig_obj[0] = args;
37964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
37965 if (!SWIG_IsOK(res1)) {
37966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
37967 }
37968 arg1 = reinterpret_cast< wxMenu * >(argp1);
37969 {
37970 PyThreadState* __tstate = wxPyBeginAllowThreads();
37971 result = (wxMenuItem *)(arg1)->AppendSeparator();
37972 wxPyEndAllowThreads(__tstate);
37973 if (PyErr_Occurred()) SWIG_fail;
37974 }
37975 {
37976 resultobj = wxPyMake_wxObject(result, (bool)0);
37977 }
37978 return resultobj;
37979 fail:
37980 return NULL;
37981 }
37982
37983
37984 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37985 PyObject *resultobj = 0;
37986 wxMenu *arg1 = (wxMenu *) 0 ;
37987 int arg2 ;
37988 wxString *arg3 = 0 ;
37989 wxString const &arg4_defvalue = wxPyEmptyString ;
37990 wxString *arg4 = (wxString *) &arg4_defvalue ;
37991 wxMenuItem *result = 0 ;
37992 void *argp1 = 0 ;
37993 int res1 = 0 ;
37994 int val2 ;
37995 int ecode2 = 0 ;
37996 bool temp3 = false ;
37997 bool temp4 = false ;
37998 PyObject * obj0 = 0 ;
37999 PyObject * obj1 = 0 ;
38000 PyObject * obj2 = 0 ;
38001 PyObject * obj3 = 0 ;
38002 char * kwnames[] = {
38003 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38004 };
38005
38006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38008 if (!SWIG_IsOK(res1)) {
38009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38010 }
38011 arg1 = reinterpret_cast< wxMenu * >(argp1);
38012 ecode2 = SWIG_AsVal_int(obj1, &val2);
38013 if (!SWIG_IsOK(ecode2)) {
38014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38015 }
38016 arg2 = static_cast< int >(val2);
38017 {
38018 arg3 = wxString_in_helper(obj2);
38019 if (arg3 == NULL) SWIG_fail;
38020 temp3 = true;
38021 }
38022 if (obj3) {
38023 {
38024 arg4 = wxString_in_helper(obj3);
38025 if (arg4 == NULL) SWIG_fail;
38026 temp4 = true;
38027 }
38028 }
38029 {
38030 PyThreadState* __tstate = wxPyBeginAllowThreads();
38031 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38032 wxPyEndAllowThreads(__tstate);
38033 if (PyErr_Occurred()) SWIG_fail;
38034 }
38035 {
38036 resultobj = wxPyMake_wxObject(result, (bool)0);
38037 }
38038 {
38039 if (temp3)
38040 delete arg3;
38041 }
38042 {
38043 if (temp4)
38044 delete arg4;
38045 }
38046 return resultobj;
38047 fail:
38048 {
38049 if (temp3)
38050 delete arg3;
38051 }
38052 {
38053 if (temp4)
38054 delete arg4;
38055 }
38056 return NULL;
38057 }
38058
38059
38060 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38061 PyObject *resultobj = 0;
38062 wxMenu *arg1 = (wxMenu *) 0 ;
38063 int arg2 ;
38064 wxString *arg3 = 0 ;
38065 wxString const &arg4_defvalue = wxPyEmptyString ;
38066 wxString *arg4 = (wxString *) &arg4_defvalue ;
38067 wxMenuItem *result = 0 ;
38068 void *argp1 = 0 ;
38069 int res1 = 0 ;
38070 int val2 ;
38071 int ecode2 = 0 ;
38072 bool temp3 = false ;
38073 bool temp4 = false ;
38074 PyObject * obj0 = 0 ;
38075 PyObject * obj1 = 0 ;
38076 PyObject * obj2 = 0 ;
38077 PyObject * obj3 = 0 ;
38078 char * kwnames[] = {
38079 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38080 };
38081
38082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38084 if (!SWIG_IsOK(res1)) {
38085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38086 }
38087 arg1 = reinterpret_cast< wxMenu * >(argp1);
38088 ecode2 = SWIG_AsVal_int(obj1, &val2);
38089 if (!SWIG_IsOK(ecode2)) {
38090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38091 }
38092 arg2 = static_cast< int >(val2);
38093 {
38094 arg3 = wxString_in_helper(obj2);
38095 if (arg3 == NULL) SWIG_fail;
38096 temp3 = true;
38097 }
38098 if (obj3) {
38099 {
38100 arg4 = wxString_in_helper(obj3);
38101 if (arg4 == NULL) SWIG_fail;
38102 temp4 = true;
38103 }
38104 }
38105 {
38106 PyThreadState* __tstate = wxPyBeginAllowThreads();
38107 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38108 wxPyEndAllowThreads(__tstate);
38109 if (PyErr_Occurred()) SWIG_fail;
38110 }
38111 {
38112 resultobj = wxPyMake_wxObject(result, (bool)0);
38113 }
38114 {
38115 if (temp3)
38116 delete arg3;
38117 }
38118 {
38119 if (temp4)
38120 delete arg4;
38121 }
38122 return resultobj;
38123 fail:
38124 {
38125 if (temp3)
38126 delete arg3;
38127 }
38128 {
38129 if (temp4)
38130 delete arg4;
38131 }
38132 return NULL;
38133 }
38134
38135
38136 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38137 PyObject *resultobj = 0;
38138 wxMenu *arg1 = (wxMenu *) 0 ;
38139 int arg2 ;
38140 wxString *arg3 = 0 ;
38141 wxMenu *arg4 = (wxMenu *) 0 ;
38142 wxString const &arg5_defvalue = wxPyEmptyString ;
38143 wxString *arg5 = (wxString *) &arg5_defvalue ;
38144 wxMenuItem *result = 0 ;
38145 void *argp1 = 0 ;
38146 int res1 = 0 ;
38147 int val2 ;
38148 int ecode2 = 0 ;
38149 bool temp3 = false ;
38150 void *argp4 = 0 ;
38151 int res4 = 0 ;
38152 bool temp5 = false ;
38153 PyObject * obj0 = 0 ;
38154 PyObject * obj1 = 0 ;
38155 PyObject * obj2 = 0 ;
38156 PyObject * obj3 = 0 ;
38157 PyObject * obj4 = 0 ;
38158 char * kwnames[] = {
38159 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38160 };
38161
38162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38164 if (!SWIG_IsOK(res1)) {
38165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38166 }
38167 arg1 = reinterpret_cast< wxMenu * >(argp1);
38168 ecode2 = SWIG_AsVal_int(obj1, &val2);
38169 if (!SWIG_IsOK(ecode2)) {
38170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38171 }
38172 arg2 = static_cast< int >(val2);
38173 {
38174 arg3 = wxString_in_helper(obj2);
38175 if (arg3 == NULL) SWIG_fail;
38176 temp3 = true;
38177 }
38178 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38179 if (!SWIG_IsOK(res4)) {
38180 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38181 }
38182 arg4 = reinterpret_cast< wxMenu * >(argp4);
38183 if (obj4) {
38184 {
38185 arg5 = wxString_in_helper(obj4);
38186 if (arg5 == NULL) SWIG_fail;
38187 temp5 = true;
38188 }
38189 }
38190 {
38191 PyThreadState* __tstate = wxPyBeginAllowThreads();
38192 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38193 wxPyEndAllowThreads(__tstate);
38194 if (PyErr_Occurred()) SWIG_fail;
38195 }
38196 {
38197 resultobj = wxPyMake_wxObject(result, (bool)0);
38198 }
38199 {
38200 if (temp3)
38201 delete arg3;
38202 }
38203 {
38204 if (temp5)
38205 delete arg5;
38206 }
38207 return resultobj;
38208 fail:
38209 {
38210 if (temp3)
38211 delete arg3;
38212 }
38213 {
38214 if (temp5)
38215 delete arg5;
38216 }
38217 return NULL;
38218 }
38219
38220
38221 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38222 PyObject *resultobj = 0;
38223 wxMenu *arg1 = (wxMenu *) 0 ;
38224 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38225 wxMenuItem *result = 0 ;
38226 void *argp1 = 0 ;
38227 int res1 = 0 ;
38228 int res2 = 0 ;
38229 PyObject * obj0 = 0 ;
38230 PyObject * obj1 = 0 ;
38231 char * kwnames[] = {
38232 (char *) "self",(char *) "item", NULL
38233 };
38234
38235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38237 if (!SWIG_IsOK(res1)) {
38238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38239 }
38240 arg1 = reinterpret_cast< wxMenu * >(argp1);
38241 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38242 if (!SWIG_IsOK(res2)) {
38243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38244 }
38245 {
38246 PyThreadState* __tstate = wxPyBeginAllowThreads();
38247 result = (wxMenuItem *)(arg1)->Append(arg2);
38248 wxPyEndAllowThreads(__tstate);
38249 if (PyErr_Occurred()) SWIG_fail;
38250 }
38251 {
38252 resultobj = wxPyMake_wxObject(result, (bool)0);
38253 }
38254 return resultobj;
38255 fail:
38256 return NULL;
38257 }
38258
38259
38260 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38261 PyObject *resultobj = 0;
38262 wxMenu *arg1 = (wxMenu *) 0 ;
38263 size_t arg2 ;
38264 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38265 wxMenuItem *result = 0 ;
38266 void *argp1 = 0 ;
38267 int res1 = 0 ;
38268 size_t val2 ;
38269 int ecode2 = 0 ;
38270 int res3 = 0 ;
38271 PyObject * obj0 = 0 ;
38272 PyObject * obj1 = 0 ;
38273 PyObject * obj2 = 0 ;
38274 char * kwnames[] = {
38275 (char *) "self",(char *) "pos",(char *) "item", NULL
38276 };
38277
38278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38280 if (!SWIG_IsOK(res1)) {
38281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38282 }
38283 arg1 = reinterpret_cast< wxMenu * >(argp1);
38284 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38285 if (!SWIG_IsOK(ecode2)) {
38286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38287 }
38288 arg2 = static_cast< size_t >(val2);
38289 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38290 if (!SWIG_IsOK(res3)) {
38291 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38292 }
38293 {
38294 PyThreadState* __tstate = wxPyBeginAllowThreads();
38295 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38296 wxPyEndAllowThreads(__tstate);
38297 if (PyErr_Occurred()) SWIG_fail;
38298 }
38299 {
38300 resultobj = wxPyMake_wxObject(result, (bool)0);
38301 }
38302 return resultobj;
38303 fail:
38304 return NULL;
38305 }
38306
38307
38308 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38309 PyObject *resultobj = 0;
38310 wxMenu *arg1 = (wxMenu *) 0 ;
38311 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38312 wxMenuItem *result = 0 ;
38313 void *argp1 = 0 ;
38314 int res1 = 0 ;
38315 int res2 = 0 ;
38316 PyObject * obj0 = 0 ;
38317 PyObject * obj1 = 0 ;
38318 char * kwnames[] = {
38319 (char *) "self",(char *) "item", NULL
38320 };
38321
38322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38324 if (!SWIG_IsOK(res1)) {
38325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38326 }
38327 arg1 = reinterpret_cast< wxMenu * >(argp1);
38328 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38329 if (!SWIG_IsOK(res2)) {
38330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38331 }
38332 {
38333 PyThreadState* __tstate = wxPyBeginAllowThreads();
38334 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38335 wxPyEndAllowThreads(__tstate);
38336 if (PyErr_Occurred()) SWIG_fail;
38337 }
38338 {
38339 resultobj = wxPyMake_wxObject(result, (bool)0);
38340 }
38341 return resultobj;
38342 fail:
38343 return NULL;
38344 }
38345
38346
38347 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38348 PyObject *resultobj = 0;
38349 wxMenu *arg1 = (wxMenu *) 0 ;
38350 void *argp1 = 0 ;
38351 int res1 = 0 ;
38352 PyObject *swig_obj[1] ;
38353
38354 if (!args) SWIG_fail;
38355 swig_obj[0] = args;
38356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38357 if (!SWIG_IsOK(res1)) {
38358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38359 }
38360 arg1 = reinterpret_cast< wxMenu * >(argp1);
38361 {
38362 PyThreadState* __tstate = wxPyBeginAllowThreads();
38363 (arg1)->Break();
38364 wxPyEndAllowThreads(__tstate);
38365 if (PyErr_Occurred()) SWIG_fail;
38366 }
38367 resultobj = SWIG_Py_Void();
38368 return resultobj;
38369 fail:
38370 return NULL;
38371 }
38372
38373
38374 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38375 PyObject *resultobj = 0;
38376 wxMenu *arg1 = (wxMenu *) 0 ;
38377 size_t arg2 ;
38378 int arg3 ;
38379 wxString *arg4 = 0 ;
38380 wxString const &arg5_defvalue = wxPyEmptyString ;
38381 wxString *arg5 = (wxString *) &arg5_defvalue ;
38382 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38383 wxMenuItem *result = 0 ;
38384 void *argp1 = 0 ;
38385 int res1 = 0 ;
38386 size_t val2 ;
38387 int ecode2 = 0 ;
38388 int val3 ;
38389 int ecode3 = 0 ;
38390 bool temp4 = false ;
38391 bool temp5 = false ;
38392 int val6 ;
38393 int ecode6 = 0 ;
38394 PyObject * obj0 = 0 ;
38395 PyObject * obj1 = 0 ;
38396 PyObject * obj2 = 0 ;
38397 PyObject * obj3 = 0 ;
38398 PyObject * obj4 = 0 ;
38399 PyObject * obj5 = 0 ;
38400 char * kwnames[] = {
38401 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38402 };
38403
38404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38406 if (!SWIG_IsOK(res1)) {
38407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38408 }
38409 arg1 = reinterpret_cast< wxMenu * >(argp1);
38410 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38411 if (!SWIG_IsOK(ecode2)) {
38412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38413 }
38414 arg2 = static_cast< size_t >(val2);
38415 ecode3 = SWIG_AsVal_int(obj2, &val3);
38416 if (!SWIG_IsOK(ecode3)) {
38417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38418 }
38419 arg3 = static_cast< int >(val3);
38420 {
38421 arg4 = wxString_in_helper(obj3);
38422 if (arg4 == NULL) SWIG_fail;
38423 temp4 = true;
38424 }
38425 if (obj4) {
38426 {
38427 arg5 = wxString_in_helper(obj4);
38428 if (arg5 == NULL) SWIG_fail;
38429 temp5 = true;
38430 }
38431 }
38432 if (obj5) {
38433 ecode6 = SWIG_AsVal_int(obj5, &val6);
38434 if (!SWIG_IsOK(ecode6)) {
38435 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38436 }
38437 arg6 = static_cast< wxItemKind >(val6);
38438 }
38439 {
38440 PyThreadState* __tstate = wxPyBeginAllowThreads();
38441 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38442 wxPyEndAllowThreads(__tstate);
38443 if (PyErr_Occurred()) SWIG_fail;
38444 }
38445 {
38446 resultobj = wxPyMake_wxObject(result, (bool)0);
38447 }
38448 {
38449 if (temp4)
38450 delete arg4;
38451 }
38452 {
38453 if (temp5)
38454 delete arg5;
38455 }
38456 return resultobj;
38457 fail:
38458 {
38459 if (temp4)
38460 delete arg4;
38461 }
38462 {
38463 if (temp5)
38464 delete arg5;
38465 }
38466 return NULL;
38467 }
38468
38469
38470 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38471 PyObject *resultobj = 0;
38472 wxMenu *arg1 = (wxMenu *) 0 ;
38473 size_t arg2 ;
38474 wxMenuItem *result = 0 ;
38475 void *argp1 = 0 ;
38476 int res1 = 0 ;
38477 size_t val2 ;
38478 int ecode2 = 0 ;
38479 PyObject * obj0 = 0 ;
38480 PyObject * obj1 = 0 ;
38481 char * kwnames[] = {
38482 (char *) "self",(char *) "pos", NULL
38483 };
38484
38485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38487 if (!SWIG_IsOK(res1)) {
38488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38489 }
38490 arg1 = reinterpret_cast< wxMenu * >(argp1);
38491 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38492 if (!SWIG_IsOK(ecode2)) {
38493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38494 }
38495 arg2 = static_cast< size_t >(val2);
38496 {
38497 PyThreadState* __tstate = wxPyBeginAllowThreads();
38498 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38499 wxPyEndAllowThreads(__tstate);
38500 if (PyErr_Occurred()) SWIG_fail;
38501 }
38502 {
38503 resultobj = wxPyMake_wxObject(result, (bool)0);
38504 }
38505 return resultobj;
38506 fail:
38507 return NULL;
38508 }
38509
38510
38511 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38512 PyObject *resultobj = 0;
38513 wxMenu *arg1 = (wxMenu *) 0 ;
38514 size_t arg2 ;
38515 int arg3 ;
38516 wxString *arg4 = 0 ;
38517 wxString const &arg5_defvalue = wxPyEmptyString ;
38518 wxString *arg5 = (wxString *) &arg5_defvalue ;
38519 wxMenuItem *result = 0 ;
38520 void *argp1 = 0 ;
38521 int res1 = 0 ;
38522 size_t val2 ;
38523 int ecode2 = 0 ;
38524 int val3 ;
38525 int ecode3 = 0 ;
38526 bool temp4 = false ;
38527 bool temp5 = false ;
38528 PyObject * obj0 = 0 ;
38529 PyObject * obj1 = 0 ;
38530 PyObject * obj2 = 0 ;
38531 PyObject * obj3 = 0 ;
38532 PyObject * obj4 = 0 ;
38533 char * kwnames[] = {
38534 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38535 };
38536
38537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38539 if (!SWIG_IsOK(res1)) {
38540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38541 }
38542 arg1 = reinterpret_cast< wxMenu * >(argp1);
38543 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38544 if (!SWIG_IsOK(ecode2)) {
38545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38546 }
38547 arg2 = static_cast< size_t >(val2);
38548 ecode3 = SWIG_AsVal_int(obj2, &val3);
38549 if (!SWIG_IsOK(ecode3)) {
38550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38551 }
38552 arg3 = static_cast< int >(val3);
38553 {
38554 arg4 = wxString_in_helper(obj3);
38555 if (arg4 == NULL) SWIG_fail;
38556 temp4 = true;
38557 }
38558 if (obj4) {
38559 {
38560 arg5 = wxString_in_helper(obj4);
38561 if (arg5 == NULL) SWIG_fail;
38562 temp5 = true;
38563 }
38564 }
38565 {
38566 PyThreadState* __tstate = wxPyBeginAllowThreads();
38567 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38568 wxPyEndAllowThreads(__tstate);
38569 if (PyErr_Occurred()) SWIG_fail;
38570 }
38571 {
38572 resultobj = wxPyMake_wxObject(result, (bool)0);
38573 }
38574 {
38575 if (temp4)
38576 delete arg4;
38577 }
38578 {
38579 if (temp5)
38580 delete arg5;
38581 }
38582 return resultobj;
38583 fail:
38584 {
38585 if (temp4)
38586 delete arg4;
38587 }
38588 {
38589 if (temp5)
38590 delete arg5;
38591 }
38592 return NULL;
38593 }
38594
38595
38596 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38597 PyObject *resultobj = 0;
38598 wxMenu *arg1 = (wxMenu *) 0 ;
38599 size_t arg2 ;
38600 int arg3 ;
38601 wxString *arg4 = 0 ;
38602 wxString const &arg5_defvalue = wxPyEmptyString ;
38603 wxString *arg5 = (wxString *) &arg5_defvalue ;
38604 wxMenuItem *result = 0 ;
38605 void *argp1 = 0 ;
38606 int res1 = 0 ;
38607 size_t val2 ;
38608 int ecode2 = 0 ;
38609 int val3 ;
38610 int ecode3 = 0 ;
38611 bool temp4 = false ;
38612 bool temp5 = false ;
38613 PyObject * obj0 = 0 ;
38614 PyObject * obj1 = 0 ;
38615 PyObject * obj2 = 0 ;
38616 PyObject * obj3 = 0 ;
38617 PyObject * obj4 = 0 ;
38618 char * kwnames[] = {
38619 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38620 };
38621
38622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38624 if (!SWIG_IsOK(res1)) {
38625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38626 }
38627 arg1 = reinterpret_cast< wxMenu * >(argp1);
38628 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38629 if (!SWIG_IsOK(ecode2)) {
38630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38631 }
38632 arg2 = static_cast< size_t >(val2);
38633 ecode3 = SWIG_AsVal_int(obj2, &val3);
38634 if (!SWIG_IsOK(ecode3)) {
38635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38636 }
38637 arg3 = static_cast< int >(val3);
38638 {
38639 arg4 = wxString_in_helper(obj3);
38640 if (arg4 == NULL) SWIG_fail;
38641 temp4 = true;
38642 }
38643 if (obj4) {
38644 {
38645 arg5 = wxString_in_helper(obj4);
38646 if (arg5 == NULL) SWIG_fail;
38647 temp5 = true;
38648 }
38649 }
38650 {
38651 PyThreadState* __tstate = wxPyBeginAllowThreads();
38652 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38653 wxPyEndAllowThreads(__tstate);
38654 if (PyErr_Occurred()) SWIG_fail;
38655 }
38656 {
38657 resultobj = wxPyMake_wxObject(result, (bool)0);
38658 }
38659 {
38660 if (temp4)
38661 delete arg4;
38662 }
38663 {
38664 if (temp5)
38665 delete arg5;
38666 }
38667 return resultobj;
38668 fail:
38669 {
38670 if (temp4)
38671 delete arg4;
38672 }
38673 {
38674 if (temp5)
38675 delete arg5;
38676 }
38677 return NULL;
38678 }
38679
38680
38681 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38682 PyObject *resultobj = 0;
38683 wxMenu *arg1 = (wxMenu *) 0 ;
38684 size_t arg2 ;
38685 int arg3 ;
38686 wxString *arg4 = 0 ;
38687 wxMenu *arg5 = (wxMenu *) 0 ;
38688 wxString const &arg6_defvalue = wxPyEmptyString ;
38689 wxString *arg6 = (wxString *) &arg6_defvalue ;
38690 wxMenuItem *result = 0 ;
38691 void *argp1 = 0 ;
38692 int res1 = 0 ;
38693 size_t val2 ;
38694 int ecode2 = 0 ;
38695 int val3 ;
38696 int ecode3 = 0 ;
38697 bool temp4 = false ;
38698 void *argp5 = 0 ;
38699 int res5 = 0 ;
38700 bool temp6 = false ;
38701 PyObject * obj0 = 0 ;
38702 PyObject * obj1 = 0 ;
38703 PyObject * obj2 = 0 ;
38704 PyObject * obj3 = 0 ;
38705 PyObject * obj4 = 0 ;
38706 PyObject * obj5 = 0 ;
38707 char * kwnames[] = {
38708 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38709 };
38710
38711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38713 if (!SWIG_IsOK(res1)) {
38714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38715 }
38716 arg1 = reinterpret_cast< wxMenu * >(argp1);
38717 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38718 if (!SWIG_IsOK(ecode2)) {
38719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38720 }
38721 arg2 = static_cast< size_t >(val2);
38722 ecode3 = SWIG_AsVal_int(obj2, &val3);
38723 if (!SWIG_IsOK(ecode3)) {
38724 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38725 }
38726 arg3 = static_cast< int >(val3);
38727 {
38728 arg4 = wxString_in_helper(obj3);
38729 if (arg4 == NULL) SWIG_fail;
38730 temp4 = true;
38731 }
38732 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
38733 if (!SWIG_IsOK(res5)) {
38734 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
38735 }
38736 arg5 = reinterpret_cast< wxMenu * >(argp5);
38737 if (obj5) {
38738 {
38739 arg6 = wxString_in_helper(obj5);
38740 if (arg6 == NULL) SWIG_fail;
38741 temp6 = true;
38742 }
38743 }
38744 {
38745 PyThreadState* __tstate = wxPyBeginAllowThreads();
38746 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
38747 wxPyEndAllowThreads(__tstate);
38748 if (PyErr_Occurred()) SWIG_fail;
38749 }
38750 {
38751 resultobj = wxPyMake_wxObject(result, (bool)0);
38752 }
38753 {
38754 if (temp4)
38755 delete arg4;
38756 }
38757 {
38758 if (temp6)
38759 delete arg6;
38760 }
38761 return resultobj;
38762 fail:
38763 {
38764 if (temp4)
38765 delete arg4;
38766 }
38767 {
38768 if (temp6)
38769 delete arg6;
38770 }
38771 return NULL;
38772 }
38773
38774
38775 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38776 PyObject *resultobj = 0;
38777 wxMenu *arg1 = (wxMenu *) 0 ;
38778 int arg2 ;
38779 wxString *arg3 = 0 ;
38780 wxString const &arg4_defvalue = wxPyEmptyString ;
38781 wxString *arg4 = (wxString *) &arg4_defvalue ;
38782 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38783 wxMenuItem *result = 0 ;
38784 void *argp1 = 0 ;
38785 int res1 = 0 ;
38786 int val2 ;
38787 int ecode2 = 0 ;
38788 bool temp3 = false ;
38789 bool temp4 = false ;
38790 int val5 ;
38791 int ecode5 = 0 ;
38792 PyObject * obj0 = 0 ;
38793 PyObject * obj1 = 0 ;
38794 PyObject * obj2 = 0 ;
38795 PyObject * obj3 = 0 ;
38796 PyObject * obj4 = 0 ;
38797 char * kwnames[] = {
38798 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38799 };
38800
38801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38803 if (!SWIG_IsOK(res1)) {
38804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
38805 }
38806 arg1 = reinterpret_cast< wxMenu * >(argp1);
38807 ecode2 = SWIG_AsVal_int(obj1, &val2);
38808 if (!SWIG_IsOK(ecode2)) {
38809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
38810 }
38811 arg2 = static_cast< int >(val2);
38812 {
38813 arg3 = wxString_in_helper(obj2);
38814 if (arg3 == NULL) SWIG_fail;
38815 temp3 = true;
38816 }
38817 if (obj3) {
38818 {
38819 arg4 = wxString_in_helper(obj3);
38820 if (arg4 == NULL) SWIG_fail;
38821 temp4 = true;
38822 }
38823 }
38824 if (obj4) {
38825 ecode5 = SWIG_AsVal_int(obj4, &val5);
38826 if (!SWIG_IsOK(ecode5)) {
38827 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
38828 }
38829 arg5 = static_cast< wxItemKind >(val5);
38830 }
38831 {
38832 PyThreadState* __tstate = wxPyBeginAllowThreads();
38833 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38834 wxPyEndAllowThreads(__tstate);
38835 if (PyErr_Occurred()) SWIG_fail;
38836 }
38837 {
38838 resultobj = wxPyMake_wxObject(result, (bool)0);
38839 }
38840 {
38841 if (temp3)
38842 delete arg3;
38843 }
38844 {
38845 if (temp4)
38846 delete arg4;
38847 }
38848 return resultobj;
38849 fail:
38850 {
38851 if (temp3)
38852 delete arg3;
38853 }
38854 {
38855 if (temp4)
38856 delete arg4;
38857 }
38858 return NULL;
38859 }
38860
38861
38862 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38863 PyObject *resultobj = 0;
38864 wxMenu *arg1 = (wxMenu *) 0 ;
38865 wxMenuItem *result = 0 ;
38866 void *argp1 = 0 ;
38867 int res1 = 0 ;
38868 PyObject *swig_obj[1] ;
38869
38870 if (!args) SWIG_fail;
38871 swig_obj[0] = args;
38872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38873 if (!SWIG_IsOK(res1)) {
38874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38875 }
38876 arg1 = reinterpret_cast< wxMenu * >(argp1);
38877 {
38878 PyThreadState* __tstate = wxPyBeginAllowThreads();
38879 result = (wxMenuItem *)(arg1)->PrependSeparator();
38880 wxPyEndAllowThreads(__tstate);
38881 if (PyErr_Occurred()) SWIG_fail;
38882 }
38883 {
38884 resultobj = wxPyMake_wxObject(result, (bool)0);
38885 }
38886 return resultobj;
38887 fail:
38888 return NULL;
38889 }
38890
38891
38892 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38893 PyObject *resultobj = 0;
38894 wxMenu *arg1 = (wxMenu *) 0 ;
38895 int arg2 ;
38896 wxString *arg3 = 0 ;
38897 wxString const &arg4_defvalue = wxPyEmptyString ;
38898 wxString *arg4 = (wxString *) &arg4_defvalue ;
38899 wxMenuItem *result = 0 ;
38900 void *argp1 = 0 ;
38901 int res1 = 0 ;
38902 int val2 ;
38903 int ecode2 = 0 ;
38904 bool temp3 = false ;
38905 bool temp4 = false ;
38906 PyObject * obj0 = 0 ;
38907 PyObject * obj1 = 0 ;
38908 PyObject * obj2 = 0 ;
38909 PyObject * obj3 = 0 ;
38910 char * kwnames[] = {
38911 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38912 };
38913
38914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38916 if (!SWIG_IsOK(res1)) {
38917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38918 }
38919 arg1 = reinterpret_cast< wxMenu * >(argp1);
38920 ecode2 = SWIG_AsVal_int(obj1, &val2);
38921 if (!SWIG_IsOK(ecode2)) {
38922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
38923 }
38924 arg2 = static_cast< int >(val2);
38925 {
38926 arg3 = wxString_in_helper(obj2);
38927 if (arg3 == NULL) SWIG_fail;
38928 temp3 = true;
38929 }
38930 if (obj3) {
38931 {
38932 arg4 = wxString_in_helper(obj3);
38933 if (arg4 == NULL) SWIG_fail;
38934 temp4 = true;
38935 }
38936 }
38937 {
38938 PyThreadState* __tstate = wxPyBeginAllowThreads();
38939 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38940 wxPyEndAllowThreads(__tstate);
38941 if (PyErr_Occurred()) SWIG_fail;
38942 }
38943 {
38944 resultobj = wxPyMake_wxObject(result, (bool)0);
38945 }
38946 {
38947 if (temp3)
38948 delete arg3;
38949 }
38950 {
38951 if (temp4)
38952 delete arg4;
38953 }
38954 return resultobj;
38955 fail:
38956 {
38957 if (temp3)
38958 delete arg3;
38959 }
38960 {
38961 if (temp4)
38962 delete arg4;
38963 }
38964 return NULL;
38965 }
38966
38967
38968 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38969 PyObject *resultobj = 0;
38970 wxMenu *arg1 = (wxMenu *) 0 ;
38971 int arg2 ;
38972 wxString *arg3 = 0 ;
38973 wxString const &arg4_defvalue = wxPyEmptyString ;
38974 wxString *arg4 = (wxString *) &arg4_defvalue ;
38975 wxMenuItem *result = 0 ;
38976 void *argp1 = 0 ;
38977 int res1 = 0 ;
38978 int val2 ;
38979 int ecode2 = 0 ;
38980 bool temp3 = false ;
38981 bool temp4 = false ;
38982 PyObject * obj0 = 0 ;
38983 PyObject * obj1 = 0 ;
38984 PyObject * obj2 = 0 ;
38985 PyObject * obj3 = 0 ;
38986 char * kwnames[] = {
38987 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38988 };
38989
38990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38992 if (!SWIG_IsOK(res1)) {
38993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38994 }
38995 arg1 = reinterpret_cast< wxMenu * >(argp1);
38996 ecode2 = SWIG_AsVal_int(obj1, &val2);
38997 if (!SWIG_IsOK(ecode2)) {
38998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
38999 }
39000 arg2 = static_cast< int >(val2);
39001 {
39002 arg3 = wxString_in_helper(obj2);
39003 if (arg3 == NULL) SWIG_fail;
39004 temp3 = true;
39005 }
39006 if (obj3) {
39007 {
39008 arg4 = wxString_in_helper(obj3);
39009 if (arg4 == NULL) SWIG_fail;
39010 temp4 = true;
39011 }
39012 }
39013 {
39014 PyThreadState* __tstate = wxPyBeginAllowThreads();
39015 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39016 wxPyEndAllowThreads(__tstate);
39017 if (PyErr_Occurred()) SWIG_fail;
39018 }
39019 {
39020 resultobj = wxPyMake_wxObject(result, (bool)0);
39021 }
39022 {
39023 if (temp3)
39024 delete arg3;
39025 }
39026 {
39027 if (temp4)
39028 delete arg4;
39029 }
39030 return resultobj;
39031 fail:
39032 {
39033 if (temp3)
39034 delete arg3;
39035 }
39036 {
39037 if (temp4)
39038 delete arg4;
39039 }
39040 return NULL;
39041 }
39042
39043
39044 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39045 PyObject *resultobj = 0;
39046 wxMenu *arg1 = (wxMenu *) 0 ;
39047 int arg2 ;
39048 wxString *arg3 = 0 ;
39049 wxMenu *arg4 = (wxMenu *) 0 ;
39050 wxString const &arg5_defvalue = wxPyEmptyString ;
39051 wxString *arg5 = (wxString *) &arg5_defvalue ;
39052 wxMenuItem *result = 0 ;
39053 void *argp1 = 0 ;
39054 int res1 = 0 ;
39055 int val2 ;
39056 int ecode2 = 0 ;
39057 bool temp3 = false ;
39058 void *argp4 = 0 ;
39059 int res4 = 0 ;
39060 bool temp5 = false ;
39061 PyObject * obj0 = 0 ;
39062 PyObject * obj1 = 0 ;
39063 PyObject * obj2 = 0 ;
39064 PyObject * obj3 = 0 ;
39065 PyObject * obj4 = 0 ;
39066 char * kwnames[] = {
39067 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39068 };
39069
39070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39072 if (!SWIG_IsOK(res1)) {
39073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39074 }
39075 arg1 = reinterpret_cast< wxMenu * >(argp1);
39076 ecode2 = SWIG_AsVal_int(obj1, &val2);
39077 if (!SWIG_IsOK(ecode2)) {
39078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39079 }
39080 arg2 = static_cast< int >(val2);
39081 {
39082 arg3 = wxString_in_helper(obj2);
39083 if (arg3 == NULL) SWIG_fail;
39084 temp3 = true;
39085 }
39086 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39087 if (!SWIG_IsOK(res4)) {
39088 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39089 }
39090 arg4 = reinterpret_cast< wxMenu * >(argp4);
39091 if (obj4) {
39092 {
39093 arg5 = wxString_in_helper(obj4);
39094 if (arg5 == NULL) SWIG_fail;
39095 temp5 = true;
39096 }
39097 }
39098 {
39099 PyThreadState* __tstate = wxPyBeginAllowThreads();
39100 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39101 wxPyEndAllowThreads(__tstate);
39102 if (PyErr_Occurred()) SWIG_fail;
39103 }
39104 {
39105 resultobj = wxPyMake_wxObject(result, (bool)0);
39106 }
39107 {
39108 if (temp3)
39109 delete arg3;
39110 }
39111 {
39112 if (temp5)
39113 delete arg5;
39114 }
39115 return resultobj;
39116 fail:
39117 {
39118 if (temp3)
39119 delete arg3;
39120 }
39121 {
39122 if (temp5)
39123 delete arg5;
39124 }
39125 return NULL;
39126 }
39127
39128
39129 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39130 PyObject *resultobj = 0;
39131 wxMenu *arg1 = (wxMenu *) 0 ;
39132 int arg2 ;
39133 wxMenuItem *result = 0 ;
39134 void *argp1 = 0 ;
39135 int res1 = 0 ;
39136 int val2 ;
39137 int ecode2 = 0 ;
39138 PyObject * obj0 = 0 ;
39139 PyObject * obj1 = 0 ;
39140 char * kwnames[] = {
39141 (char *) "self",(char *) "id", NULL
39142 };
39143
39144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39146 if (!SWIG_IsOK(res1)) {
39147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39148 }
39149 arg1 = reinterpret_cast< wxMenu * >(argp1);
39150 ecode2 = SWIG_AsVal_int(obj1, &val2);
39151 if (!SWIG_IsOK(ecode2)) {
39152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39153 }
39154 arg2 = static_cast< int >(val2);
39155 {
39156 PyThreadState* __tstate = wxPyBeginAllowThreads();
39157 result = (wxMenuItem *)(arg1)->Remove(arg2);
39158 wxPyEndAllowThreads(__tstate);
39159 if (PyErr_Occurred()) SWIG_fail;
39160 }
39161 {
39162 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39163 }
39164 return resultobj;
39165 fail:
39166 return NULL;
39167 }
39168
39169
39170 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39171 PyObject *resultobj = 0;
39172 wxMenu *arg1 = (wxMenu *) 0 ;
39173 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39174 wxMenuItem *result = 0 ;
39175 void *argp1 = 0 ;
39176 int res1 = 0 ;
39177 void *argp2 = 0 ;
39178 int res2 = 0 ;
39179 PyObject * obj0 = 0 ;
39180 PyObject * obj1 = 0 ;
39181 char * kwnames[] = {
39182 (char *) "self",(char *) "item", NULL
39183 };
39184
39185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39187 if (!SWIG_IsOK(res1)) {
39188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39189 }
39190 arg1 = reinterpret_cast< wxMenu * >(argp1);
39191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39192 if (!SWIG_IsOK(res2)) {
39193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39194 }
39195 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39196 {
39197 PyThreadState* __tstate = wxPyBeginAllowThreads();
39198 result = (wxMenuItem *)(arg1)->Remove(arg2);
39199 wxPyEndAllowThreads(__tstate);
39200 if (PyErr_Occurred()) SWIG_fail;
39201 }
39202 {
39203 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39204 }
39205 return resultobj;
39206 fail:
39207 return NULL;
39208 }
39209
39210
39211 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39212 PyObject *resultobj = 0;
39213 wxMenu *arg1 = (wxMenu *) 0 ;
39214 int arg2 ;
39215 bool result;
39216 void *argp1 = 0 ;
39217 int res1 = 0 ;
39218 int val2 ;
39219 int ecode2 = 0 ;
39220 PyObject * obj0 = 0 ;
39221 PyObject * obj1 = 0 ;
39222 char * kwnames[] = {
39223 (char *) "self",(char *) "id", NULL
39224 };
39225
39226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39228 if (!SWIG_IsOK(res1)) {
39229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39230 }
39231 arg1 = reinterpret_cast< wxMenu * >(argp1);
39232 ecode2 = SWIG_AsVal_int(obj1, &val2);
39233 if (!SWIG_IsOK(ecode2)) {
39234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39235 }
39236 arg2 = static_cast< int >(val2);
39237 {
39238 PyThreadState* __tstate = wxPyBeginAllowThreads();
39239 result = (bool)(arg1)->Delete(arg2);
39240 wxPyEndAllowThreads(__tstate);
39241 if (PyErr_Occurred()) SWIG_fail;
39242 }
39243 {
39244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39245 }
39246 return resultobj;
39247 fail:
39248 return NULL;
39249 }
39250
39251
39252 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39253 PyObject *resultobj = 0;
39254 wxMenu *arg1 = (wxMenu *) 0 ;
39255 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39256 bool result;
39257 void *argp1 = 0 ;
39258 int res1 = 0 ;
39259 void *argp2 = 0 ;
39260 int res2 = 0 ;
39261 PyObject * obj0 = 0 ;
39262 PyObject * obj1 = 0 ;
39263 char * kwnames[] = {
39264 (char *) "self",(char *) "item", NULL
39265 };
39266
39267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39269 if (!SWIG_IsOK(res1)) {
39270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39271 }
39272 arg1 = reinterpret_cast< wxMenu * >(argp1);
39273 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39274 if (!SWIG_IsOK(res2)) {
39275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39276 }
39277 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39278 {
39279 PyThreadState* __tstate = wxPyBeginAllowThreads();
39280 result = (bool)(arg1)->Delete(arg2);
39281 wxPyEndAllowThreads(__tstate);
39282 if (PyErr_Occurred()) SWIG_fail;
39283 }
39284 {
39285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39286 }
39287 return resultobj;
39288 fail:
39289 return NULL;
39290 }
39291
39292
39293 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39294 PyObject *resultobj = 0;
39295 wxMenu *arg1 = (wxMenu *) 0 ;
39296 void *argp1 = 0 ;
39297 int res1 = 0 ;
39298 PyObject *swig_obj[1] ;
39299
39300 if (!args) SWIG_fail;
39301 swig_obj[0] = args;
39302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39303 if (!SWIG_IsOK(res1)) {
39304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39305 }
39306 arg1 = reinterpret_cast< wxMenu * >(argp1);
39307 {
39308 PyThreadState* __tstate = wxPyBeginAllowThreads();
39309 wxMenu_Destroy(arg1);
39310 wxPyEndAllowThreads(__tstate);
39311 if (PyErr_Occurred()) SWIG_fail;
39312 }
39313 resultobj = SWIG_Py_Void();
39314 return resultobj;
39315 fail:
39316 return NULL;
39317 }
39318
39319
39320 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39321 PyObject *resultobj = 0;
39322 wxMenu *arg1 = (wxMenu *) 0 ;
39323 int arg2 ;
39324 bool result;
39325 void *argp1 = 0 ;
39326 int res1 = 0 ;
39327 int val2 ;
39328 int ecode2 = 0 ;
39329 PyObject * obj0 = 0 ;
39330 PyObject * obj1 = 0 ;
39331 char * kwnames[] = {
39332 (char *) "self",(char *) "id", NULL
39333 };
39334
39335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39337 if (!SWIG_IsOK(res1)) {
39338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39339 }
39340 arg1 = reinterpret_cast< wxMenu * >(argp1);
39341 ecode2 = SWIG_AsVal_int(obj1, &val2);
39342 if (!SWIG_IsOK(ecode2)) {
39343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39344 }
39345 arg2 = static_cast< int >(val2);
39346 {
39347 PyThreadState* __tstate = wxPyBeginAllowThreads();
39348 result = (bool)(arg1)->Destroy(arg2);
39349 wxPyEndAllowThreads(__tstate);
39350 if (PyErr_Occurred()) SWIG_fail;
39351 }
39352 {
39353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39354 }
39355 return resultobj;
39356 fail:
39357 return NULL;
39358 }
39359
39360
39361 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39362 PyObject *resultobj = 0;
39363 wxMenu *arg1 = (wxMenu *) 0 ;
39364 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39365 bool result;
39366 void *argp1 = 0 ;
39367 int res1 = 0 ;
39368 void *argp2 = 0 ;
39369 int res2 = 0 ;
39370 PyObject * obj0 = 0 ;
39371 PyObject * obj1 = 0 ;
39372 char * kwnames[] = {
39373 (char *) "self",(char *) "item", NULL
39374 };
39375
39376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39378 if (!SWIG_IsOK(res1)) {
39379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39380 }
39381 arg1 = reinterpret_cast< wxMenu * >(argp1);
39382 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39383 if (!SWIG_IsOK(res2)) {
39384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39385 }
39386 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39387 {
39388 PyThreadState* __tstate = wxPyBeginAllowThreads();
39389 result = (bool)(arg1)->Destroy(arg2);
39390 wxPyEndAllowThreads(__tstate);
39391 if (PyErr_Occurred()) SWIG_fail;
39392 }
39393 {
39394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39395 }
39396 return resultobj;
39397 fail:
39398 return NULL;
39399 }
39400
39401
39402 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39403 PyObject *resultobj = 0;
39404 wxMenu *arg1 = (wxMenu *) 0 ;
39405 size_t result;
39406 void *argp1 = 0 ;
39407 int res1 = 0 ;
39408 PyObject *swig_obj[1] ;
39409
39410 if (!args) SWIG_fail;
39411 swig_obj[0] = args;
39412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39413 if (!SWIG_IsOK(res1)) {
39414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39415 }
39416 arg1 = reinterpret_cast< wxMenu * >(argp1);
39417 {
39418 PyThreadState* __tstate = wxPyBeginAllowThreads();
39419 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39420 wxPyEndAllowThreads(__tstate);
39421 if (PyErr_Occurred()) SWIG_fail;
39422 }
39423 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39424 return resultobj;
39425 fail:
39426 return NULL;
39427 }
39428
39429
39430 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39431 PyObject *resultobj = 0;
39432 wxMenu *arg1 = (wxMenu *) 0 ;
39433 PyObject *result = 0 ;
39434 void *argp1 = 0 ;
39435 int res1 = 0 ;
39436 PyObject *swig_obj[1] ;
39437
39438 if (!args) SWIG_fail;
39439 swig_obj[0] = args;
39440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39441 if (!SWIG_IsOK(res1)) {
39442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39443 }
39444 arg1 = reinterpret_cast< wxMenu * >(argp1);
39445 {
39446 PyThreadState* __tstate = wxPyBeginAllowThreads();
39447 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39448 wxPyEndAllowThreads(__tstate);
39449 if (PyErr_Occurred()) SWIG_fail;
39450 }
39451 resultobj = result;
39452 return resultobj;
39453 fail:
39454 return NULL;
39455 }
39456
39457
39458 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39459 PyObject *resultobj = 0;
39460 wxMenu *arg1 = (wxMenu *) 0 ;
39461 wxString *arg2 = 0 ;
39462 int result;
39463 void *argp1 = 0 ;
39464 int res1 = 0 ;
39465 bool temp2 = false ;
39466 PyObject * obj0 = 0 ;
39467 PyObject * obj1 = 0 ;
39468 char * kwnames[] = {
39469 (char *) "self",(char *) "item", NULL
39470 };
39471
39472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39474 if (!SWIG_IsOK(res1)) {
39475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39476 }
39477 arg1 = reinterpret_cast< wxMenu * >(argp1);
39478 {
39479 arg2 = wxString_in_helper(obj1);
39480 if (arg2 == NULL) SWIG_fail;
39481 temp2 = true;
39482 }
39483 {
39484 PyThreadState* __tstate = wxPyBeginAllowThreads();
39485 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39486 wxPyEndAllowThreads(__tstate);
39487 if (PyErr_Occurred()) SWIG_fail;
39488 }
39489 resultobj = SWIG_From_int(static_cast< int >(result));
39490 {
39491 if (temp2)
39492 delete arg2;
39493 }
39494 return resultobj;
39495 fail:
39496 {
39497 if (temp2)
39498 delete arg2;
39499 }
39500 return NULL;
39501 }
39502
39503
39504 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39505 PyObject *resultobj = 0;
39506 wxMenu *arg1 = (wxMenu *) 0 ;
39507 int arg2 ;
39508 wxMenuItem *result = 0 ;
39509 void *argp1 = 0 ;
39510 int res1 = 0 ;
39511 int val2 ;
39512 int ecode2 = 0 ;
39513 PyObject * obj0 = 0 ;
39514 PyObject * obj1 = 0 ;
39515 char * kwnames[] = {
39516 (char *) "self",(char *) "id", NULL
39517 };
39518
39519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39521 if (!SWIG_IsOK(res1)) {
39522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39523 }
39524 arg1 = reinterpret_cast< wxMenu * >(argp1);
39525 ecode2 = SWIG_AsVal_int(obj1, &val2);
39526 if (!SWIG_IsOK(ecode2)) {
39527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39528 }
39529 arg2 = static_cast< int >(val2);
39530 {
39531 PyThreadState* __tstate = wxPyBeginAllowThreads();
39532 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39533 wxPyEndAllowThreads(__tstate);
39534 if (PyErr_Occurred()) SWIG_fail;
39535 }
39536 {
39537 resultobj = wxPyMake_wxObject(result, (bool)0);
39538 }
39539 return resultobj;
39540 fail:
39541 return NULL;
39542 }
39543
39544
39545 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39546 PyObject *resultobj = 0;
39547 wxMenu *arg1 = (wxMenu *) 0 ;
39548 size_t arg2 ;
39549 wxMenuItem *result = 0 ;
39550 void *argp1 = 0 ;
39551 int res1 = 0 ;
39552 size_t val2 ;
39553 int ecode2 = 0 ;
39554 PyObject * obj0 = 0 ;
39555 PyObject * obj1 = 0 ;
39556 char * kwnames[] = {
39557 (char *) "self",(char *) "position", NULL
39558 };
39559
39560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39562 if (!SWIG_IsOK(res1)) {
39563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39564 }
39565 arg1 = reinterpret_cast< wxMenu * >(argp1);
39566 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39567 if (!SWIG_IsOK(ecode2)) {
39568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39569 }
39570 arg2 = static_cast< size_t >(val2);
39571 {
39572 PyThreadState* __tstate = wxPyBeginAllowThreads();
39573 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39574 wxPyEndAllowThreads(__tstate);
39575 if (PyErr_Occurred()) SWIG_fail;
39576 }
39577 {
39578 resultobj = wxPyMake_wxObject(result, (bool)0);
39579 }
39580 return resultobj;
39581 fail:
39582 return NULL;
39583 }
39584
39585
39586 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39587 PyObject *resultobj = 0;
39588 wxMenu *arg1 = (wxMenu *) 0 ;
39589 int arg2 ;
39590 bool arg3 ;
39591 void *argp1 = 0 ;
39592 int res1 = 0 ;
39593 int val2 ;
39594 int ecode2 = 0 ;
39595 bool val3 ;
39596 int ecode3 = 0 ;
39597 PyObject * obj0 = 0 ;
39598 PyObject * obj1 = 0 ;
39599 PyObject * obj2 = 0 ;
39600 char * kwnames[] = {
39601 (char *) "self",(char *) "id",(char *) "enable", NULL
39602 };
39603
39604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39606 if (!SWIG_IsOK(res1)) {
39607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39608 }
39609 arg1 = reinterpret_cast< wxMenu * >(argp1);
39610 ecode2 = SWIG_AsVal_int(obj1, &val2);
39611 if (!SWIG_IsOK(ecode2)) {
39612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39613 }
39614 arg2 = static_cast< int >(val2);
39615 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39616 if (!SWIG_IsOK(ecode3)) {
39617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39618 }
39619 arg3 = static_cast< bool >(val3);
39620 {
39621 PyThreadState* __tstate = wxPyBeginAllowThreads();
39622 (arg1)->Enable(arg2,arg3);
39623 wxPyEndAllowThreads(__tstate);
39624 if (PyErr_Occurred()) SWIG_fail;
39625 }
39626 resultobj = SWIG_Py_Void();
39627 return resultobj;
39628 fail:
39629 return NULL;
39630 }
39631
39632
39633 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39634 PyObject *resultobj = 0;
39635 wxMenu *arg1 = (wxMenu *) 0 ;
39636 int arg2 ;
39637 bool result;
39638 void *argp1 = 0 ;
39639 int res1 = 0 ;
39640 int val2 ;
39641 int ecode2 = 0 ;
39642 PyObject * obj0 = 0 ;
39643 PyObject * obj1 = 0 ;
39644 char * kwnames[] = {
39645 (char *) "self",(char *) "id", NULL
39646 };
39647
39648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39650 if (!SWIG_IsOK(res1)) {
39651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39652 }
39653 arg1 = reinterpret_cast< wxMenu * >(argp1);
39654 ecode2 = SWIG_AsVal_int(obj1, &val2);
39655 if (!SWIG_IsOK(ecode2)) {
39656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39657 }
39658 arg2 = static_cast< int >(val2);
39659 {
39660 PyThreadState* __tstate = wxPyBeginAllowThreads();
39661 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39662 wxPyEndAllowThreads(__tstate);
39663 if (PyErr_Occurred()) SWIG_fail;
39664 }
39665 {
39666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39667 }
39668 return resultobj;
39669 fail:
39670 return NULL;
39671 }
39672
39673
39674 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39675 PyObject *resultobj = 0;
39676 wxMenu *arg1 = (wxMenu *) 0 ;
39677 int arg2 ;
39678 bool arg3 ;
39679 void *argp1 = 0 ;
39680 int res1 = 0 ;
39681 int val2 ;
39682 int ecode2 = 0 ;
39683 bool val3 ;
39684 int ecode3 = 0 ;
39685 PyObject * obj0 = 0 ;
39686 PyObject * obj1 = 0 ;
39687 PyObject * obj2 = 0 ;
39688 char * kwnames[] = {
39689 (char *) "self",(char *) "id",(char *) "check", NULL
39690 };
39691
39692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39694 if (!SWIG_IsOK(res1)) {
39695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39696 }
39697 arg1 = reinterpret_cast< wxMenu * >(argp1);
39698 ecode2 = SWIG_AsVal_int(obj1, &val2);
39699 if (!SWIG_IsOK(ecode2)) {
39700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39701 }
39702 arg2 = static_cast< int >(val2);
39703 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39704 if (!SWIG_IsOK(ecode3)) {
39705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39706 }
39707 arg3 = static_cast< bool >(val3);
39708 {
39709 PyThreadState* __tstate = wxPyBeginAllowThreads();
39710 (arg1)->Check(arg2,arg3);
39711 wxPyEndAllowThreads(__tstate);
39712 if (PyErr_Occurred()) SWIG_fail;
39713 }
39714 resultobj = SWIG_Py_Void();
39715 return resultobj;
39716 fail:
39717 return NULL;
39718 }
39719
39720
39721 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39722 PyObject *resultobj = 0;
39723 wxMenu *arg1 = (wxMenu *) 0 ;
39724 int arg2 ;
39725 bool result;
39726 void *argp1 = 0 ;
39727 int res1 = 0 ;
39728 int val2 ;
39729 int ecode2 = 0 ;
39730 PyObject * obj0 = 0 ;
39731 PyObject * obj1 = 0 ;
39732 char * kwnames[] = {
39733 (char *) "self",(char *) "id", NULL
39734 };
39735
39736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
39737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39738 if (!SWIG_IsOK(res1)) {
39739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
39740 }
39741 arg1 = reinterpret_cast< wxMenu * >(argp1);
39742 ecode2 = SWIG_AsVal_int(obj1, &val2);
39743 if (!SWIG_IsOK(ecode2)) {
39744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
39745 }
39746 arg2 = static_cast< int >(val2);
39747 {
39748 PyThreadState* __tstate = wxPyBeginAllowThreads();
39749 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
39750 wxPyEndAllowThreads(__tstate);
39751 if (PyErr_Occurred()) SWIG_fail;
39752 }
39753 {
39754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39755 }
39756 return resultobj;
39757 fail:
39758 return NULL;
39759 }
39760
39761
39762 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39763 PyObject *resultobj = 0;
39764 wxMenu *arg1 = (wxMenu *) 0 ;
39765 int arg2 ;
39766 wxString *arg3 = 0 ;
39767 void *argp1 = 0 ;
39768 int res1 = 0 ;
39769 int val2 ;
39770 int ecode2 = 0 ;
39771 bool temp3 = false ;
39772 PyObject * obj0 = 0 ;
39773 PyObject * obj1 = 0 ;
39774 PyObject * obj2 = 0 ;
39775 char * kwnames[] = {
39776 (char *) "self",(char *) "id",(char *) "label", NULL
39777 };
39778
39779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39781 if (!SWIG_IsOK(res1)) {
39782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
39783 }
39784 arg1 = reinterpret_cast< wxMenu * >(argp1);
39785 ecode2 = SWIG_AsVal_int(obj1, &val2);
39786 if (!SWIG_IsOK(ecode2)) {
39787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
39788 }
39789 arg2 = static_cast< int >(val2);
39790 {
39791 arg3 = wxString_in_helper(obj2);
39792 if (arg3 == NULL) SWIG_fail;
39793 temp3 = true;
39794 }
39795 {
39796 PyThreadState* __tstate = wxPyBeginAllowThreads();
39797 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
39798 wxPyEndAllowThreads(__tstate);
39799 if (PyErr_Occurred()) SWIG_fail;
39800 }
39801 resultobj = SWIG_Py_Void();
39802 {
39803 if (temp3)
39804 delete arg3;
39805 }
39806 return resultobj;
39807 fail:
39808 {
39809 if (temp3)
39810 delete arg3;
39811 }
39812 return NULL;
39813 }
39814
39815
39816 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39817 PyObject *resultobj = 0;
39818 wxMenu *arg1 = (wxMenu *) 0 ;
39819 int arg2 ;
39820 wxString result;
39821 void *argp1 = 0 ;
39822 int res1 = 0 ;
39823 int val2 ;
39824 int ecode2 = 0 ;
39825 PyObject * obj0 = 0 ;
39826 PyObject * obj1 = 0 ;
39827 char * kwnames[] = {
39828 (char *) "self",(char *) "id", NULL
39829 };
39830
39831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39833 if (!SWIG_IsOK(res1)) {
39834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
39835 }
39836 arg1 = reinterpret_cast< wxMenu * >(argp1);
39837 ecode2 = SWIG_AsVal_int(obj1, &val2);
39838 if (!SWIG_IsOK(ecode2)) {
39839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
39840 }
39841 arg2 = static_cast< int >(val2);
39842 {
39843 PyThreadState* __tstate = wxPyBeginAllowThreads();
39844 result = ((wxMenu const *)arg1)->GetLabel(arg2);
39845 wxPyEndAllowThreads(__tstate);
39846 if (PyErr_Occurred()) SWIG_fail;
39847 }
39848 {
39849 #if wxUSE_UNICODE
39850 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39851 #else
39852 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39853 #endif
39854 }
39855 return resultobj;
39856 fail:
39857 return NULL;
39858 }
39859
39860
39861 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39862 PyObject *resultobj = 0;
39863 wxMenu *arg1 = (wxMenu *) 0 ;
39864 int arg2 ;
39865 wxString *arg3 = 0 ;
39866 void *argp1 = 0 ;
39867 int res1 = 0 ;
39868 int val2 ;
39869 int ecode2 = 0 ;
39870 bool temp3 = false ;
39871 PyObject * obj0 = 0 ;
39872 PyObject * obj1 = 0 ;
39873 PyObject * obj2 = 0 ;
39874 char * kwnames[] = {
39875 (char *) "self",(char *) "id",(char *) "helpString", NULL
39876 };
39877
39878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39880 if (!SWIG_IsOK(res1)) {
39881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
39882 }
39883 arg1 = reinterpret_cast< wxMenu * >(argp1);
39884 ecode2 = SWIG_AsVal_int(obj1, &val2);
39885 if (!SWIG_IsOK(ecode2)) {
39886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
39887 }
39888 arg2 = static_cast< int >(val2);
39889 {
39890 arg3 = wxString_in_helper(obj2);
39891 if (arg3 == NULL) SWIG_fail;
39892 temp3 = true;
39893 }
39894 {
39895 PyThreadState* __tstate = wxPyBeginAllowThreads();
39896 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
39897 wxPyEndAllowThreads(__tstate);
39898 if (PyErr_Occurred()) SWIG_fail;
39899 }
39900 resultobj = SWIG_Py_Void();
39901 {
39902 if (temp3)
39903 delete arg3;
39904 }
39905 return resultobj;
39906 fail:
39907 {
39908 if (temp3)
39909 delete arg3;
39910 }
39911 return NULL;
39912 }
39913
39914
39915 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39916 PyObject *resultobj = 0;
39917 wxMenu *arg1 = (wxMenu *) 0 ;
39918 int arg2 ;
39919 wxString result;
39920 void *argp1 = 0 ;
39921 int res1 = 0 ;
39922 int val2 ;
39923 int ecode2 = 0 ;
39924 PyObject * obj0 = 0 ;
39925 PyObject * obj1 = 0 ;
39926 char * kwnames[] = {
39927 (char *) "self",(char *) "id", NULL
39928 };
39929
39930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
39931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39932 if (!SWIG_IsOK(res1)) {
39933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
39934 }
39935 arg1 = reinterpret_cast< wxMenu * >(argp1);
39936 ecode2 = SWIG_AsVal_int(obj1, &val2);
39937 if (!SWIG_IsOK(ecode2)) {
39938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
39939 }
39940 arg2 = static_cast< int >(val2);
39941 {
39942 PyThreadState* __tstate = wxPyBeginAllowThreads();
39943 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
39944 wxPyEndAllowThreads(__tstate);
39945 if (PyErr_Occurred()) SWIG_fail;
39946 }
39947 {
39948 #if wxUSE_UNICODE
39949 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39950 #else
39951 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39952 #endif
39953 }
39954 return resultobj;
39955 fail:
39956 return NULL;
39957 }
39958
39959
39960 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39961 PyObject *resultobj = 0;
39962 wxMenu *arg1 = (wxMenu *) 0 ;
39963 wxString *arg2 = 0 ;
39964 void *argp1 = 0 ;
39965 int res1 = 0 ;
39966 bool temp2 = false ;
39967 PyObject * obj0 = 0 ;
39968 PyObject * obj1 = 0 ;
39969 char * kwnames[] = {
39970 (char *) "self",(char *) "title", NULL
39971 };
39972
39973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
39974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39975 if (!SWIG_IsOK(res1)) {
39976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
39977 }
39978 arg1 = reinterpret_cast< wxMenu * >(argp1);
39979 {
39980 arg2 = wxString_in_helper(obj1);
39981 if (arg2 == NULL) SWIG_fail;
39982 temp2 = true;
39983 }
39984 {
39985 PyThreadState* __tstate = wxPyBeginAllowThreads();
39986 (arg1)->SetTitle((wxString const &)*arg2);
39987 wxPyEndAllowThreads(__tstate);
39988 if (PyErr_Occurred()) SWIG_fail;
39989 }
39990 resultobj = SWIG_Py_Void();
39991 {
39992 if (temp2)
39993 delete arg2;
39994 }
39995 return resultobj;
39996 fail:
39997 {
39998 if (temp2)
39999 delete arg2;
40000 }
40001 return NULL;
40002 }
40003
40004
40005 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40006 PyObject *resultobj = 0;
40007 wxMenu *arg1 = (wxMenu *) 0 ;
40008 wxString result;
40009 void *argp1 = 0 ;
40010 int res1 = 0 ;
40011 PyObject *swig_obj[1] ;
40012
40013 if (!args) SWIG_fail;
40014 swig_obj[0] = args;
40015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40016 if (!SWIG_IsOK(res1)) {
40017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40018 }
40019 arg1 = reinterpret_cast< wxMenu * >(argp1);
40020 {
40021 PyThreadState* __tstate = wxPyBeginAllowThreads();
40022 result = ((wxMenu const *)arg1)->GetTitle();
40023 wxPyEndAllowThreads(__tstate);
40024 if (PyErr_Occurred()) SWIG_fail;
40025 }
40026 {
40027 #if wxUSE_UNICODE
40028 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40029 #else
40030 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40031 #endif
40032 }
40033 return resultobj;
40034 fail:
40035 return NULL;
40036 }
40037
40038
40039 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40040 PyObject *resultobj = 0;
40041 wxMenu *arg1 = (wxMenu *) 0 ;
40042 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40043 void *argp1 = 0 ;
40044 int res1 = 0 ;
40045 void *argp2 = 0 ;
40046 int res2 = 0 ;
40047 PyObject * obj0 = 0 ;
40048 PyObject * obj1 = 0 ;
40049 char * kwnames[] = {
40050 (char *) "self",(char *) "handler", NULL
40051 };
40052
40053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40055 if (!SWIG_IsOK(res1)) {
40056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40057 }
40058 arg1 = reinterpret_cast< wxMenu * >(argp1);
40059 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40060 if (!SWIG_IsOK(res2)) {
40061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40062 }
40063 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40064 {
40065 PyThreadState* __tstate = wxPyBeginAllowThreads();
40066 (arg1)->SetEventHandler(arg2);
40067 wxPyEndAllowThreads(__tstate);
40068 if (PyErr_Occurred()) SWIG_fail;
40069 }
40070 resultobj = SWIG_Py_Void();
40071 return resultobj;
40072 fail:
40073 return NULL;
40074 }
40075
40076
40077 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40078 PyObject *resultobj = 0;
40079 wxMenu *arg1 = (wxMenu *) 0 ;
40080 wxEvtHandler *result = 0 ;
40081 void *argp1 = 0 ;
40082 int res1 = 0 ;
40083 PyObject *swig_obj[1] ;
40084
40085 if (!args) SWIG_fail;
40086 swig_obj[0] = args;
40087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40088 if (!SWIG_IsOK(res1)) {
40089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40090 }
40091 arg1 = reinterpret_cast< wxMenu * >(argp1);
40092 {
40093 PyThreadState* __tstate = wxPyBeginAllowThreads();
40094 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40095 wxPyEndAllowThreads(__tstate);
40096 if (PyErr_Occurred()) SWIG_fail;
40097 }
40098 {
40099 resultobj = wxPyMake_wxObject(result, 0);
40100 }
40101 return resultobj;
40102 fail:
40103 return NULL;
40104 }
40105
40106
40107 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40108 PyObject *resultobj = 0;
40109 wxMenu *arg1 = (wxMenu *) 0 ;
40110 wxWindow *arg2 = (wxWindow *) 0 ;
40111 void *argp1 = 0 ;
40112 int res1 = 0 ;
40113 void *argp2 = 0 ;
40114 int res2 = 0 ;
40115 PyObject * obj0 = 0 ;
40116 PyObject * obj1 = 0 ;
40117 char * kwnames[] = {
40118 (char *) "self",(char *) "win", NULL
40119 };
40120
40121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40123 if (!SWIG_IsOK(res1)) {
40124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40125 }
40126 arg1 = reinterpret_cast< wxMenu * >(argp1);
40127 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40128 if (!SWIG_IsOK(res2)) {
40129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40130 }
40131 arg2 = reinterpret_cast< wxWindow * >(argp2);
40132 {
40133 PyThreadState* __tstate = wxPyBeginAllowThreads();
40134 (arg1)->SetInvokingWindow(arg2);
40135 wxPyEndAllowThreads(__tstate);
40136 if (PyErr_Occurred()) SWIG_fail;
40137 }
40138 resultobj = SWIG_Py_Void();
40139 return resultobj;
40140 fail:
40141 return NULL;
40142 }
40143
40144
40145 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40146 PyObject *resultobj = 0;
40147 wxMenu *arg1 = (wxMenu *) 0 ;
40148 wxWindow *result = 0 ;
40149 void *argp1 = 0 ;
40150 int res1 = 0 ;
40151 PyObject *swig_obj[1] ;
40152
40153 if (!args) SWIG_fail;
40154 swig_obj[0] = args;
40155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40156 if (!SWIG_IsOK(res1)) {
40157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40158 }
40159 arg1 = reinterpret_cast< wxMenu * >(argp1);
40160 {
40161 PyThreadState* __tstate = wxPyBeginAllowThreads();
40162 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40163 wxPyEndAllowThreads(__tstate);
40164 if (PyErr_Occurred()) SWIG_fail;
40165 }
40166 {
40167 resultobj = wxPyMake_wxObject(result, 0);
40168 }
40169 return resultobj;
40170 fail:
40171 return NULL;
40172 }
40173
40174
40175 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40176 PyObject *resultobj = 0;
40177 wxMenu *arg1 = (wxMenu *) 0 ;
40178 long result;
40179 void *argp1 = 0 ;
40180 int res1 = 0 ;
40181 PyObject *swig_obj[1] ;
40182
40183 if (!args) SWIG_fail;
40184 swig_obj[0] = args;
40185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40186 if (!SWIG_IsOK(res1)) {
40187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40188 }
40189 arg1 = reinterpret_cast< wxMenu * >(argp1);
40190 {
40191 PyThreadState* __tstate = wxPyBeginAllowThreads();
40192 result = (long)((wxMenu const *)arg1)->GetStyle();
40193 wxPyEndAllowThreads(__tstate);
40194 if (PyErr_Occurred()) SWIG_fail;
40195 }
40196 resultobj = SWIG_From_long(static_cast< long >(result));
40197 return resultobj;
40198 fail:
40199 return NULL;
40200 }
40201
40202
40203 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40204 PyObject *resultobj = 0;
40205 wxMenu *arg1 = (wxMenu *) 0 ;
40206 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40207 void *argp1 = 0 ;
40208 int res1 = 0 ;
40209 void *argp2 = 0 ;
40210 int res2 = 0 ;
40211 PyObject * obj0 = 0 ;
40212 PyObject * obj1 = 0 ;
40213 char * kwnames[] = {
40214 (char *) "self",(char *) "source", NULL
40215 };
40216
40217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40219 if (!SWIG_IsOK(res1)) {
40220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40221 }
40222 arg1 = reinterpret_cast< wxMenu * >(argp1);
40223 if (obj1) {
40224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40225 if (!SWIG_IsOK(res2)) {
40226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40227 }
40228 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40229 }
40230 {
40231 PyThreadState* __tstate = wxPyBeginAllowThreads();
40232 (arg1)->UpdateUI(arg2);
40233 wxPyEndAllowThreads(__tstate);
40234 if (PyErr_Occurred()) SWIG_fail;
40235 }
40236 resultobj = SWIG_Py_Void();
40237 return resultobj;
40238 fail:
40239 return NULL;
40240 }
40241
40242
40243 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40244 PyObject *resultobj = 0;
40245 wxMenu *arg1 = (wxMenu *) 0 ;
40246 wxMenuBar *result = 0 ;
40247 void *argp1 = 0 ;
40248 int res1 = 0 ;
40249 PyObject *swig_obj[1] ;
40250
40251 if (!args) SWIG_fail;
40252 swig_obj[0] = args;
40253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40254 if (!SWIG_IsOK(res1)) {
40255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40256 }
40257 arg1 = reinterpret_cast< wxMenu * >(argp1);
40258 {
40259 PyThreadState* __tstate = wxPyBeginAllowThreads();
40260 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40261 wxPyEndAllowThreads(__tstate);
40262 if (PyErr_Occurred()) SWIG_fail;
40263 }
40264 {
40265 resultobj = wxPyMake_wxObject(result, (bool)0);
40266 }
40267 return resultobj;
40268 fail:
40269 return NULL;
40270 }
40271
40272
40273 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40274 PyObject *resultobj = 0;
40275 wxMenu *arg1 = (wxMenu *) 0 ;
40276 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40277 void *argp1 = 0 ;
40278 int res1 = 0 ;
40279 void *argp2 = 0 ;
40280 int res2 = 0 ;
40281 PyObject * obj0 = 0 ;
40282 PyObject * obj1 = 0 ;
40283 char * kwnames[] = {
40284 (char *) "self",(char *) "menubar", NULL
40285 };
40286
40287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40289 if (!SWIG_IsOK(res1)) {
40290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40291 }
40292 arg1 = reinterpret_cast< wxMenu * >(argp1);
40293 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40294 if (!SWIG_IsOK(res2)) {
40295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40296 }
40297 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40298 {
40299 PyThreadState* __tstate = wxPyBeginAllowThreads();
40300 (arg1)->Attach(arg2);
40301 wxPyEndAllowThreads(__tstate);
40302 if (PyErr_Occurred()) SWIG_fail;
40303 }
40304 resultobj = SWIG_Py_Void();
40305 return resultobj;
40306 fail:
40307 return NULL;
40308 }
40309
40310
40311 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40312 PyObject *resultobj = 0;
40313 wxMenu *arg1 = (wxMenu *) 0 ;
40314 void *argp1 = 0 ;
40315 int res1 = 0 ;
40316 PyObject *swig_obj[1] ;
40317
40318 if (!args) SWIG_fail;
40319 swig_obj[0] = args;
40320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40321 if (!SWIG_IsOK(res1)) {
40322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40323 }
40324 arg1 = reinterpret_cast< wxMenu * >(argp1);
40325 {
40326 PyThreadState* __tstate = wxPyBeginAllowThreads();
40327 (arg1)->Detach();
40328 wxPyEndAllowThreads(__tstate);
40329 if (PyErr_Occurred()) SWIG_fail;
40330 }
40331 resultobj = SWIG_Py_Void();
40332 return resultobj;
40333 fail:
40334 return NULL;
40335 }
40336
40337
40338 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40339 PyObject *resultobj = 0;
40340 wxMenu *arg1 = (wxMenu *) 0 ;
40341 bool result;
40342 void *argp1 = 0 ;
40343 int res1 = 0 ;
40344 PyObject *swig_obj[1] ;
40345
40346 if (!args) SWIG_fail;
40347 swig_obj[0] = args;
40348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40349 if (!SWIG_IsOK(res1)) {
40350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40351 }
40352 arg1 = reinterpret_cast< wxMenu * >(argp1);
40353 {
40354 PyThreadState* __tstate = wxPyBeginAllowThreads();
40355 result = (bool)((wxMenu const *)arg1)->IsAttached();
40356 wxPyEndAllowThreads(__tstate);
40357 if (PyErr_Occurred()) SWIG_fail;
40358 }
40359 {
40360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40361 }
40362 return resultobj;
40363 fail:
40364 return NULL;
40365 }
40366
40367
40368 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40369 PyObject *resultobj = 0;
40370 wxMenu *arg1 = (wxMenu *) 0 ;
40371 wxMenu *arg2 = (wxMenu *) 0 ;
40372 void *argp1 = 0 ;
40373 int res1 = 0 ;
40374 void *argp2 = 0 ;
40375 int res2 = 0 ;
40376 PyObject * obj0 = 0 ;
40377 PyObject * obj1 = 0 ;
40378 char * kwnames[] = {
40379 (char *) "self",(char *) "parent", NULL
40380 };
40381
40382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40384 if (!SWIG_IsOK(res1)) {
40385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40386 }
40387 arg1 = reinterpret_cast< wxMenu * >(argp1);
40388 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40389 if (!SWIG_IsOK(res2)) {
40390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40391 }
40392 arg2 = reinterpret_cast< wxMenu * >(argp2);
40393 {
40394 PyThreadState* __tstate = wxPyBeginAllowThreads();
40395 (arg1)->SetParent(arg2);
40396 wxPyEndAllowThreads(__tstate);
40397 if (PyErr_Occurred()) SWIG_fail;
40398 }
40399 resultobj = SWIG_Py_Void();
40400 return resultobj;
40401 fail:
40402 return NULL;
40403 }
40404
40405
40406 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40407 PyObject *resultobj = 0;
40408 wxMenu *arg1 = (wxMenu *) 0 ;
40409 wxMenu *result = 0 ;
40410 void *argp1 = 0 ;
40411 int res1 = 0 ;
40412 PyObject *swig_obj[1] ;
40413
40414 if (!args) SWIG_fail;
40415 swig_obj[0] = args;
40416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40417 if (!SWIG_IsOK(res1)) {
40418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40419 }
40420 arg1 = reinterpret_cast< wxMenu * >(argp1);
40421 {
40422 PyThreadState* __tstate = wxPyBeginAllowThreads();
40423 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40424 wxPyEndAllowThreads(__tstate);
40425 if (PyErr_Occurred()) SWIG_fail;
40426 }
40427 {
40428 resultobj = wxPyMake_wxObject(result, 0);
40429 }
40430 return resultobj;
40431 fail:
40432 return NULL;
40433 }
40434
40435
40436 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40437 PyObject *obj;
40438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40439 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40440 return SWIG_Py_Void();
40441 }
40442
40443 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40444 return SWIG_Python_InitShadowInstance(args);
40445 }
40446
40447 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40448 PyObject *resultobj = 0;
40449 long arg1 = (long) 0 ;
40450 wxMenuBar *result = 0 ;
40451 long val1 ;
40452 int ecode1 = 0 ;
40453 PyObject * obj0 = 0 ;
40454 char * kwnames[] = {
40455 (char *) "style", NULL
40456 };
40457
40458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40459 if (obj0) {
40460 ecode1 = SWIG_AsVal_long(obj0, &val1);
40461 if (!SWIG_IsOK(ecode1)) {
40462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40463 }
40464 arg1 = static_cast< long >(val1);
40465 }
40466 {
40467 if (!wxPyCheckForApp()) SWIG_fail;
40468 PyThreadState* __tstate = wxPyBeginAllowThreads();
40469 result = (wxMenuBar *)new wxMenuBar(arg1);
40470 wxPyEndAllowThreads(__tstate);
40471 if (PyErr_Occurred()) SWIG_fail;
40472 }
40473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40474 return resultobj;
40475 fail:
40476 return NULL;
40477 }
40478
40479
40480 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40481 PyObject *resultobj = 0;
40482 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40483 wxMenu *arg2 = (wxMenu *) 0 ;
40484 wxString *arg3 = 0 ;
40485 bool result;
40486 void *argp1 = 0 ;
40487 int res1 = 0 ;
40488 void *argp2 = 0 ;
40489 int res2 = 0 ;
40490 bool temp3 = false ;
40491 PyObject * obj0 = 0 ;
40492 PyObject * obj1 = 0 ;
40493 PyObject * obj2 = 0 ;
40494 char * kwnames[] = {
40495 (char *) "self",(char *) "menu",(char *) "title", NULL
40496 };
40497
40498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40500 if (!SWIG_IsOK(res1)) {
40501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40502 }
40503 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40504 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40505 if (!SWIG_IsOK(res2)) {
40506 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40507 }
40508 arg2 = reinterpret_cast< wxMenu * >(argp2);
40509 {
40510 arg3 = wxString_in_helper(obj2);
40511 if (arg3 == NULL) SWIG_fail;
40512 temp3 = true;
40513 }
40514 {
40515 PyThreadState* __tstate = wxPyBeginAllowThreads();
40516 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40517 wxPyEndAllowThreads(__tstate);
40518 if (PyErr_Occurred()) SWIG_fail;
40519 }
40520 {
40521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40522 }
40523 {
40524 if (temp3)
40525 delete arg3;
40526 }
40527 return resultobj;
40528 fail:
40529 {
40530 if (temp3)
40531 delete arg3;
40532 }
40533 return NULL;
40534 }
40535
40536
40537 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40538 PyObject *resultobj = 0;
40539 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40540 size_t arg2 ;
40541 wxMenu *arg3 = (wxMenu *) 0 ;
40542 wxString *arg4 = 0 ;
40543 bool result;
40544 void *argp1 = 0 ;
40545 int res1 = 0 ;
40546 size_t val2 ;
40547 int ecode2 = 0 ;
40548 void *argp3 = 0 ;
40549 int res3 = 0 ;
40550 bool temp4 = false ;
40551 PyObject * obj0 = 0 ;
40552 PyObject * obj1 = 0 ;
40553 PyObject * obj2 = 0 ;
40554 PyObject * obj3 = 0 ;
40555 char * kwnames[] = {
40556 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40557 };
40558
40559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40561 if (!SWIG_IsOK(res1)) {
40562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40563 }
40564 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40565 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40566 if (!SWIG_IsOK(ecode2)) {
40567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40568 }
40569 arg2 = static_cast< size_t >(val2);
40570 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40571 if (!SWIG_IsOK(res3)) {
40572 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40573 }
40574 arg3 = reinterpret_cast< wxMenu * >(argp3);
40575 {
40576 arg4 = wxString_in_helper(obj3);
40577 if (arg4 == NULL) SWIG_fail;
40578 temp4 = true;
40579 }
40580 {
40581 PyThreadState* __tstate = wxPyBeginAllowThreads();
40582 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40583 wxPyEndAllowThreads(__tstate);
40584 if (PyErr_Occurred()) SWIG_fail;
40585 }
40586 {
40587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40588 }
40589 {
40590 if (temp4)
40591 delete arg4;
40592 }
40593 return resultobj;
40594 fail:
40595 {
40596 if (temp4)
40597 delete arg4;
40598 }
40599 return NULL;
40600 }
40601
40602
40603 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40604 PyObject *resultobj = 0;
40605 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40606 size_t result;
40607 void *argp1 = 0 ;
40608 int res1 = 0 ;
40609 PyObject *swig_obj[1] ;
40610
40611 if (!args) SWIG_fail;
40612 swig_obj[0] = args;
40613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40614 if (!SWIG_IsOK(res1)) {
40615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40616 }
40617 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40618 {
40619 PyThreadState* __tstate = wxPyBeginAllowThreads();
40620 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40621 wxPyEndAllowThreads(__tstate);
40622 if (PyErr_Occurred()) SWIG_fail;
40623 }
40624 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40625 return resultobj;
40626 fail:
40627 return NULL;
40628 }
40629
40630
40631 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40632 PyObject *resultobj = 0;
40633 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40634 size_t arg2 ;
40635 wxMenu *result = 0 ;
40636 void *argp1 = 0 ;
40637 int res1 = 0 ;
40638 size_t val2 ;
40639 int ecode2 = 0 ;
40640 PyObject * obj0 = 0 ;
40641 PyObject * obj1 = 0 ;
40642 char * kwnames[] = {
40643 (char *) "self",(char *) "pos", NULL
40644 };
40645
40646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40648 if (!SWIG_IsOK(res1)) {
40649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40650 }
40651 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40652 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40653 if (!SWIG_IsOK(ecode2)) {
40654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40655 }
40656 arg2 = static_cast< size_t >(val2);
40657 {
40658 PyThreadState* __tstate = wxPyBeginAllowThreads();
40659 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40660 wxPyEndAllowThreads(__tstate);
40661 if (PyErr_Occurred()) SWIG_fail;
40662 }
40663 {
40664 resultobj = wxPyMake_wxObject(result, 0);
40665 }
40666 return resultobj;
40667 fail:
40668 return NULL;
40669 }
40670
40671
40672 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40673 PyObject *resultobj = 0;
40674 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40675 size_t arg2 ;
40676 wxMenu *arg3 = (wxMenu *) 0 ;
40677 wxString *arg4 = 0 ;
40678 wxMenu *result = 0 ;
40679 void *argp1 = 0 ;
40680 int res1 = 0 ;
40681 size_t val2 ;
40682 int ecode2 = 0 ;
40683 void *argp3 = 0 ;
40684 int res3 = 0 ;
40685 bool temp4 = false ;
40686 PyObject * obj0 = 0 ;
40687 PyObject * obj1 = 0 ;
40688 PyObject * obj2 = 0 ;
40689 PyObject * obj3 = 0 ;
40690 char * kwnames[] = {
40691 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40692 };
40693
40694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40696 if (!SWIG_IsOK(res1)) {
40697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40698 }
40699 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40700 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40701 if (!SWIG_IsOK(ecode2)) {
40702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40703 }
40704 arg2 = static_cast< size_t >(val2);
40705 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40706 if (!SWIG_IsOK(res3)) {
40707 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40708 }
40709 arg3 = reinterpret_cast< wxMenu * >(argp3);
40710 {
40711 arg4 = wxString_in_helper(obj3);
40712 if (arg4 == NULL) SWIG_fail;
40713 temp4 = true;
40714 }
40715 {
40716 PyThreadState* __tstate = wxPyBeginAllowThreads();
40717 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40718 wxPyEndAllowThreads(__tstate);
40719 if (PyErr_Occurred()) SWIG_fail;
40720 }
40721 {
40722 resultobj = wxPyMake_wxObject(result, 0);
40723 }
40724 {
40725 if (temp4)
40726 delete arg4;
40727 }
40728 return resultobj;
40729 fail:
40730 {
40731 if (temp4)
40732 delete arg4;
40733 }
40734 return NULL;
40735 }
40736
40737
40738 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40739 PyObject *resultobj = 0;
40740 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40741 size_t arg2 ;
40742 wxMenu *result = 0 ;
40743 void *argp1 = 0 ;
40744 int res1 = 0 ;
40745 size_t val2 ;
40746 int ecode2 = 0 ;
40747 PyObject * obj0 = 0 ;
40748 PyObject * obj1 = 0 ;
40749 char * kwnames[] = {
40750 (char *) "self",(char *) "pos", NULL
40751 };
40752
40753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40755 if (!SWIG_IsOK(res1)) {
40756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40757 }
40758 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40759 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40760 if (!SWIG_IsOK(ecode2)) {
40761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
40762 }
40763 arg2 = static_cast< size_t >(val2);
40764 {
40765 PyThreadState* __tstate = wxPyBeginAllowThreads();
40766 result = (wxMenu *)(arg1)->Remove(arg2);
40767 wxPyEndAllowThreads(__tstate);
40768 if (PyErr_Occurred()) SWIG_fail;
40769 }
40770 {
40771 resultobj = wxPyMake_wxObject(result, 0);
40772 }
40773 return resultobj;
40774 fail:
40775 return NULL;
40776 }
40777
40778
40779 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40780 PyObject *resultobj = 0;
40781 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40782 size_t arg2 ;
40783 bool arg3 ;
40784 void *argp1 = 0 ;
40785 int res1 = 0 ;
40786 size_t val2 ;
40787 int ecode2 = 0 ;
40788 bool val3 ;
40789 int ecode3 = 0 ;
40790 PyObject * obj0 = 0 ;
40791 PyObject * obj1 = 0 ;
40792 PyObject * obj2 = 0 ;
40793 char * kwnames[] = {
40794 (char *) "self",(char *) "pos",(char *) "enable", NULL
40795 };
40796
40797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40799 if (!SWIG_IsOK(res1)) {
40800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40801 }
40802 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40803 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40804 if (!SWIG_IsOK(ecode2)) {
40805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
40806 }
40807 arg2 = static_cast< size_t >(val2);
40808 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40809 if (!SWIG_IsOK(ecode3)) {
40810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
40811 }
40812 arg3 = static_cast< bool >(val3);
40813 {
40814 PyThreadState* __tstate = wxPyBeginAllowThreads();
40815 (arg1)->EnableTop(arg2,arg3);
40816 wxPyEndAllowThreads(__tstate);
40817 if (PyErr_Occurred()) SWIG_fail;
40818 }
40819 resultobj = SWIG_Py_Void();
40820 return resultobj;
40821 fail:
40822 return NULL;
40823 }
40824
40825
40826 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40827 PyObject *resultobj = 0;
40828 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40829 size_t arg2 ;
40830 bool result;
40831 void *argp1 = 0 ;
40832 int res1 = 0 ;
40833 size_t val2 ;
40834 int ecode2 = 0 ;
40835 PyObject * obj0 = 0 ;
40836 PyObject * obj1 = 0 ;
40837 char * kwnames[] = {
40838 (char *) "self",(char *) "pos", NULL
40839 };
40840
40841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
40842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40843 if (!SWIG_IsOK(res1)) {
40844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40845 }
40846 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40847 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40848 if (!SWIG_IsOK(ecode2)) {
40849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
40850 }
40851 arg2 = static_cast< size_t >(val2);
40852 {
40853 PyThreadState* __tstate = wxPyBeginAllowThreads();
40854 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
40855 wxPyEndAllowThreads(__tstate);
40856 if (PyErr_Occurred()) SWIG_fail;
40857 }
40858 {
40859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40860 }
40861 return resultobj;
40862 fail:
40863 return NULL;
40864 }
40865
40866
40867 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40868 PyObject *resultobj = 0;
40869 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40870 size_t arg2 ;
40871 wxString *arg3 = 0 ;
40872 void *argp1 = 0 ;
40873 int res1 = 0 ;
40874 size_t val2 ;
40875 int ecode2 = 0 ;
40876 bool temp3 = false ;
40877 PyObject * obj0 = 0 ;
40878 PyObject * obj1 = 0 ;
40879 PyObject * obj2 = 0 ;
40880 char * kwnames[] = {
40881 (char *) "self",(char *) "pos",(char *) "label", NULL
40882 };
40883
40884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40886 if (!SWIG_IsOK(res1)) {
40887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40888 }
40889 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40890 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40891 if (!SWIG_IsOK(ecode2)) {
40892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
40893 }
40894 arg2 = static_cast< size_t >(val2);
40895 {
40896 arg3 = wxString_in_helper(obj2);
40897 if (arg3 == NULL) SWIG_fail;
40898 temp3 = true;
40899 }
40900 {
40901 PyThreadState* __tstate = wxPyBeginAllowThreads();
40902 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
40903 wxPyEndAllowThreads(__tstate);
40904 if (PyErr_Occurred()) SWIG_fail;
40905 }
40906 resultobj = SWIG_Py_Void();
40907 {
40908 if (temp3)
40909 delete arg3;
40910 }
40911 return resultobj;
40912 fail:
40913 {
40914 if (temp3)
40915 delete arg3;
40916 }
40917 return NULL;
40918 }
40919
40920
40921 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40922 PyObject *resultobj = 0;
40923 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40924 size_t arg2 ;
40925 wxString result;
40926 void *argp1 = 0 ;
40927 int res1 = 0 ;
40928 size_t val2 ;
40929 int ecode2 = 0 ;
40930 PyObject * obj0 = 0 ;
40931 PyObject * obj1 = 0 ;
40932 char * kwnames[] = {
40933 (char *) "self",(char *) "pos", NULL
40934 };
40935
40936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
40937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40938 if (!SWIG_IsOK(res1)) {
40939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40940 }
40941 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40942 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40943 if (!SWIG_IsOK(ecode2)) {
40944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
40945 }
40946 arg2 = static_cast< size_t >(val2);
40947 {
40948 PyThreadState* __tstate = wxPyBeginAllowThreads();
40949 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
40950 wxPyEndAllowThreads(__tstate);
40951 if (PyErr_Occurred()) SWIG_fail;
40952 }
40953 {
40954 #if wxUSE_UNICODE
40955 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40956 #else
40957 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40958 #endif
40959 }
40960 return resultobj;
40961 fail:
40962 return NULL;
40963 }
40964
40965
40966 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40967 PyObject *resultobj = 0;
40968 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40969 wxString *arg2 = 0 ;
40970 wxString *arg3 = 0 ;
40971 int result;
40972 void *argp1 = 0 ;
40973 int res1 = 0 ;
40974 bool temp2 = false ;
40975 bool temp3 = false ;
40976 PyObject * obj0 = 0 ;
40977 PyObject * obj1 = 0 ;
40978 PyObject * obj2 = 0 ;
40979 char * kwnames[] = {
40980 (char *) "self",(char *) "menu",(char *) "item", NULL
40981 };
40982
40983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40985 if (!SWIG_IsOK(res1)) {
40986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40987 }
40988 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40989 {
40990 arg2 = wxString_in_helper(obj1);
40991 if (arg2 == NULL) SWIG_fail;
40992 temp2 = true;
40993 }
40994 {
40995 arg3 = wxString_in_helper(obj2);
40996 if (arg3 == NULL) SWIG_fail;
40997 temp3 = true;
40998 }
40999 {
41000 PyThreadState* __tstate = wxPyBeginAllowThreads();
41001 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41002 wxPyEndAllowThreads(__tstate);
41003 if (PyErr_Occurred()) SWIG_fail;
41004 }
41005 resultobj = SWIG_From_int(static_cast< int >(result));
41006 {
41007 if (temp2)
41008 delete arg2;
41009 }
41010 {
41011 if (temp3)
41012 delete arg3;
41013 }
41014 return resultobj;
41015 fail:
41016 {
41017 if (temp2)
41018 delete arg2;
41019 }
41020 {
41021 if (temp3)
41022 delete arg3;
41023 }
41024 return NULL;
41025 }
41026
41027
41028 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41029 PyObject *resultobj = 0;
41030 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41031 int arg2 ;
41032 wxMenuItem *result = 0 ;
41033 void *argp1 = 0 ;
41034 int res1 = 0 ;
41035 int val2 ;
41036 int ecode2 = 0 ;
41037 PyObject * obj0 = 0 ;
41038 PyObject * obj1 = 0 ;
41039 char * kwnames[] = {
41040 (char *) "self",(char *) "id", NULL
41041 };
41042
41043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41045 if (!SWIG_IsOK(res1)) {
41046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41047 }
41048 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41049 ecode2 = SWIG_AsVal_int(obj1, &val2);
41050 if (!SWIG_IsOK(ecode2)) {
41051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41052 }
41053 arg2 = static_cast< int >(val2);
41054 {
41055 PyThreadState* __tstate = wxPyBeginAllowThreads();
41056 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41057 wxPyEndAllowThreads(__tstate);
41058 if (PyErr_Occurred()) SWIG_fail;
41059 }
41060 {
41061 resultobj = wxPyMake_wxObject(result, (bool)0);
41062 }
41063 return resultobj;
41064 fail:
41065 return NULL;
41066 }
41067
41068
41069 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41070 PyObject *resultobj = 0;
41071 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41072 wxString *arg2 = 0 ;
41073 int result;
41074 void *argp1 = 0 ;
41075 int res1 = 0 ;
41076 bool temp2 = false ;
41077 PyObject * obj0 = 0 ;
41078 PyObject * obj1 = 0 ;
41079 char * kwnames[] = {
41080 (char *) "self",(char *) "title", NULL
41081 };
41082
41083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41085 if (!SWIG_IsOK(res1)) {
41086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41087 }
41088 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41089 {
41090 arg2 = wxString_in_helper(obj1);
41091 if (arg2 == NULL) SWIG_fail;
41092 temp2 = true;
41093 }
41094 {
41095 PyThreadState* __tstate = wxPyBeginAllowThreads();
41096 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41097 wxPyEndAllowThreads(__tstate);
41098 if (PyErr_Occurred()) SWIG_fail;
41099 }
41100 resultobj = SWIG_From_int(static_cast< int >(result));
41101 {
41102 if (temp2)
41103 delete arg2;
41104 }
41105 return resultobj;
41106 fail:
41107 {
41108 if (temp2)
41109 delete arg2;
41110 }
41111 return NULL;
41112 }
41113
41114
41115 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41116 PyObject *resultobj = 0;
41117 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41118 int arg2 ;
41119 bool arg3 ;
41120 void *argp1 = 0 ;
41121 int res1 = 0 ;
41122 int val2 ;
41123 int ecode2 = 0 ;
41124 bool val3 ;
41125 int ecode3 = 0 ;
41126 PyObject * obj0 = 0 ;
41127 PyObject * obj1 = 0 ;
41128 PyObject * obj2 = 0 ;
41129 char * kwnames[] = {
41130 (char *) "self",(char *) "id",(char *) "enable", NULL
41131 };
41132
41133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41135 if (!SWIG_IsOK(res1)) {
41136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41137 }
41138 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41139 ecode2 = SWIG_AsVal_int(obj1, &val2);
41140 if (!SWIG_IsOK(ecode2)) {
41141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41142 }
41143 arg2 = static_cast< int >(val2);
41144 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41145 if (!SWIG_IsOK(ecode3)) {
41146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41147 }
41148 arg3 = static_cast< bool >(val3);
41149 {
41150 PyThreadState* __tstate = wxPyBeginAllowThreads();
41151 (arg1)->Enable(arg2,arg3);
41152 wxPyEndAllowThreads(__tstate);
41153 if (PyErr_Occurred()) SWIG_fail;
41154 }
41155 resultobj = SWIG_Py_Void();
41156 return resultobj;
41157 fail:
41158 return NULL;
41159 }
41160
41161
41162 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41163 PyObject *resultobj = 0;
41164 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41165 int arg2 ;
41166 bool arg3 ;
41167 void *argp1 = 0 ;
41168 int res1 = 0 ;
41169 int val2 ;
41170 int ecode2 = 0 ;
41171 bool val3 ;
41172 int ecode3 = 0 ;
41173 PyObject * obj0 = 0 ;
41174 PyObject * obj1 = 0 ;
41175 PyObject * obj2 = 0 ;
41176 char * kwnames[] = {
41177 (char *) "self",(char *) "id",(char *) "check", NULL
41178 };
41179
41180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41182 if (!SWIG_IsOK(res1)) {
41183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41184 }
41185 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41186 ecode2 = SWIG_AsVal_int(obj1, &val2);
41187 if (!SWIG_IsOK(ecode2)) {
41188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41189 }
41190 arg2 = static_cast< int >(val2);
41191 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41192 if (!SWIG_IsOK(ecode3)) {
41193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41194 }
41195 arg3 = static_cast< bool >(val3);
41196 {
41197 PyThreadState* __tstate = wxPyBeginAllowThreads();
41198 (arg1)->Check(arg2,arg3);
41199 wxPyEndAllowThreads(__tstate);
41200 if (PyErr_Occurred()) SWIG_fail;
41201 }
41202 resultobj = SWIG_Py_Void();
41203 return resultobj;
41204 fail:
41205 return NULL;
41206 }
41207
41208
41209 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41210 PyObject *resultobj = 0;
41211 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41212 int arg2 ;
41213 bool result;
41214 void *argp1 = 0 ;
41215 int res1 = 0 ;
41216 int val2 ;
41217 int ecode2 = 0 ;
41218 PyObject * obj0 = 0 ;
41219 PyObject * obj1 = 0 ;
41220 char * kwnames[] = {
41221 (char *) "self",(char *) "id", NULL
41222 };
41223
41224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41226 if (!SWIG_IsOK(res1)) {
41227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41228 }
41229 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41230 ecode2 = SWIG_AsVal_int(obj1, &val2);
41231 if (!SWIG_IsOK(ecode2)) {
41232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41233 }
41234 arg2 = static_cast< int >(val2);
41235 {
41236 PyThreadState* __tstate = wxPyBeginAllowThreads();
41237 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41238 wxPyEndAllowThreads(__tstate);
41239 if (PyErr_Occurred()) SWIG_fail;
41240 }
41241 {
41242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41243 }
41244 return resultobj;
41245 fail:
41246 return NULL;
41247 }
41248
41249
41250 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41251 PyObject *resultobj = 0;
41252 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41253 int arg2 ;
41254 bool result;
41255 void *argp1 = 0 ;
41256 int res1 = 0 ;
41257 int val2 ;
41258 int ecode2 = 0 ;
41259 PyObject * obj0 = 0 ;
41260 PyObject * obj1 = 0 ;
41261 char * kwnames[] = {
41262 (char *) "self",(char *) "id", NULL
41263 };
41264
41265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41267 if (!SWIG_IsOK(res1)) {
41268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41269 }
41270 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41271 ecode2 = SWIG_AsVal_int(obj1, &val2);
41272 if (!SWIG_IsOK(ecode2)) {
41273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41274 }
41275 arg2 = static_cast< int >(val2);
41276 {
41277 PyThreadState* __tstate = wxPyBeginAllowThreads();
41278 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41279 wxPyEndAllowThreads(__tstate);
41280 if (PyErr_Occurred()) SWIG_fail;
41281 }
41282 {
41283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41284 }
41285 return resultobj;
41286 fail:
41287 return NULL;
41288 }
41289
41290
41291 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41292 PyObject *resultobj = 0;
41293 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41294 int arg2 ;
41295 wxString *arg3 = 0 ;
41296 void *argp1 = 0 ;
41297 int res1 = 0 ;
41298 int val2 ;
41299 int ecode2 = 0 ;
41300 bool temp3 = false ;
41301 PyObject * obj0 = 0 ;
41302 PyObject * obj1 = 0 ;
41303 PyObject * obj2 = 0 ;
41304 char * kwnames[] = {
41305 (char *) "self",(char *) "id",(char *) "label", NULL
41306 };
41307
41308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41310 if (!SWIG_IsOK(res1)) {
41311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41312 }
41313 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41314 ecode2 = SWIG_AsVal_int(obj1, &val2);
41315 if (!SWIG_IsOK(ecode2)) {
41316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41317 }
41318 arg2 = static_cast< int >(val2);
41319 {
41320 arg3 = wxString_in_helper(obj2);
41321 if (arg3 == NULL) SWIG_fail;
41322 temp3 = true;
41323 }
41324 {
41325 PyThreadState* __tstate = wxPyBeginAllowThreads();
41326 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41327 wxPyEndAllowThreads(__tstate);
41328 if (PyErr_Occurred()) SWIG_fail;
41329 }
41330 resultobj = SWIG_Py_Void();
41331 {
41332 if (temp3)
41333 delete arg3;
41334 }
41335 return resultobj;
41336 fail:
41337 {
41338 if (temp3)
41339 delete arg3;
41340 }
41341 return NULL;
41342 }
41343
41344
41345 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41346 PyObject *resultobj = 0;
41347 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41348 int arg2 ;
41349 wxString result;
41350 void *argp1 = 0 ;
41351 int res1 = 0 ;
41352 int val2 ;
41353 int ecode2 = 0 ;
41354 PyObject * obj0 = 0 ;
41355 PyObject * obj1 = 0 ;
41356 char * kwnames[] = {
41357 (char *) "self",(char *) "id", NULL
41358 };
41359
41360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41362 if (!SWIG_IsOK(res1)) {
41363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41364 }
41365 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41366 ecode2 = SWIG_AsVal_int(obj1, &val2);
41367 if (!SWIG_IsOK(ecode2)) {
41368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41369 }
41370 arg2 = static_cast< int >(val2);
41371 {
41372 PyThreadState* __tstate = wxPyBeginAllowThreads();
41373 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41374 wxPyEndAllowThreads(__tstate);
41375 if (PyErr_Occurred()) SWIG_fail;
41376 }
41377 {
41378 #if wxUSE_UNICODE
41379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41380 #else
41381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41382 #endif
41383 }
41384 return resultobj;
41385 fail:
41386 return NULL;
41387 }
41388
41389
41390 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41391 PyObject *resultobj = 0;
41392 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41393 int arg2 ;
41394 wxString *arg3 = 0 ;
41395 void *argp1 = 0 ;
41396 int res1 = 0 ;
41397 int val2 ;
41398 int ecode2 = 0 ;
41399 bool temp3 = false ;
41400 PyObject * obj0 = 0 ;
41401 PyObject * obj1 = 0 ;
41402 PyObject * obj2 = 0 ;
41403 char * kwnames[] = {
41404 (char *) "self",(char *) "id",(char *) "helpString", NULL
41405 };
41406
41407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41409 if (!SWIG_IsOK(res1)) {
41410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41411 }
41412 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41413 ecode2 = SWIG_AsVal_int(obj1, &val2);
41414 if (!SWIG_IsOK(ecode2)) {
41415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41416 }
41417 arg2 = static_cast< int >(val2);
41418 {
41419 arg3 = wxString_in_helper(obj2);
41420 if (arg3 == NULL) SWIG_fail;
41421 temp3 = true;
41422 }
41423 {
41424 PyThreadState* __tstate = wxPyBeginAllowThreads();
41425 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41426 wxPyEndAllowThreads(__tstate);
41427 if (PyErr_Occurred()) SWIG_fail;
41428 }
41429 resultobj = SWIG_Py_Void();
41430 {
41431 if (temp3)
41432 delete arg3;
41433 }
41434 return resultobj;
41435 fail:
41436 {
41437 if (temp3)
41438 delete arg3;
41439 }
41440 return NULL;
41441 }
41442
41443
41444 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41445 PyObject *resultobj = 0;
41446 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41447 int arg2 ;
41448 wxString result;
41449 void *argp1 = 0 ;
41450 int res1 = 0 ;
41451 int val2 ;
41452 int ecode2 = 0 ;
41453 PyObject * obj0 = 0 ;
41454 PyObject * obj1 = 0 ;
41455 char * kwnames[] = {
41456 (char *) "self",(char *) "id", NULL
41457 };
41458
41459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41461 if (!SWIG_IsOK(res1)) {
41462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41463 }
41464 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41465 ecode2 = SWIG_AsVal_int(obj1, &val2);
41466 if (!SWIG_IsOK(ecode2)) {
41467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41468 }
41469 arg2 = static_cast< int >(val2);
41470 {
41471 PyThreadState* __tstate = wxPyBeginAllowThreads();
41472 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41473 wxPyEndAllowThreads(__tstate);
41474 if (PyErr_Occurred()) SWIG_fail;
41475 }
41476 {
41477 #if wxUSE_UNICODE
41478 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41479 #else
41480 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41481 #endif
41482 }
41483 return resultobj;
41484 fail:
41485 return NULL;
41486 }
41487
41488
41489 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41490 PyObject *resultobj = 0;
41491 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41492 wxFrame *result = 0 ;
41493 void *argp1 = 0 ;
41494 int res1 = 0 ;
41495 PyObject *swig_obj[1] ;
41496
41497 if (!args) SWIG_fail;
41498 swig_obj[0] = args;
41499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41500 if (!SWIG_IsOK(res1)) {
41501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41502 }
41503 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41504 {
41505 PyThreadState* __tstate = wxPyBeginAllowThreads();
41506 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41507 wxPyEndAllowThreads(__tstate);
41508 if (PyErr_Occurred()) SWIG_fail;
41509 }
41510 {
41511 resultobj = wxPyMake_wxObject(result, (bool)0);
41512 }
41513 return resultobj;
41514 fail:
41515 return NULL;
41516 }
41517
41518
41519 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41520 PyObject *resultobj = 0;
41521 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41522 bool result;
41523 void *argp1 = 0 ;
41524 int res1 = 0 ;
41525 PyObject *swig_obj[1] ;
41526
41527 if (!args) SWIG_fail;
41528 swig_obj[0] = args;
41529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41530 if (!SWIG_IsOK(res1)) {
41531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41532 }
41533 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41534 {
41535 PyThreadState* __tstate = wxPyBeginAllowThreads();
41536 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41537 wxPyEndAllowThreads(__tstate);
41538 if (PyErr_Occurred()) SWIG_fail;
41539 }
41540 {
41541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41542 }
41543 return resultobj;
41544 fail:
41545 return NULL;
41546 }
41547
41548
41549 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41550 PyObject *resultobj = 0;
41551 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41552 wxFrame *arg2 = (wxFrame *) 0 ;
41553 void *argp1 = 0 ;
41554 int res1 = 0 ;
41555 void *argp2 = 0 ;
41556 int res2 = 0 ;
41557 PyObject * obj0 = 0 ;
41558 PyObject * obj1 = 0 ;
41559 char * kwnames[] = {
41560 (char *) "self",(char *) "frame", NULL
41561 };
41562
41563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41565 if (!SWIG_IsOK(res1)) {
41566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41567 }
41568 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41569 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41570 if (!SWIG_IsOK(res2)) {
41571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41572 }
41573 arg2 = reinterpret_cast< wxFrame * >(argp2);
41574 {
41575 PyThreadState* __tstate = wxPyBeginAllowThreads();
41576 (arg1)->Attach(arg2);
41577 wxPyEndAllowThreads(__tstate);
41578 if (PyErr_Occurred()) SWIG_fail;
41579 }
41580 resultobj = SWIG_Py_Void();
41581 return resultobj;
41582 fail:
41583 return NULL;
41584 }
41585
41586
41587 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41588 PyObject *resultobj = 0;
41589 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41590 void *argp1 = 0 ;
41591 int res1 = 0 ;
41592 PyObject *swig_obj[1] ;
41593
41594 if (!args) SWIG_fail;
41595 swig_obj[0] = args;
41596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41597 if (!SWIG_IsOK(res1)) {
41598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41599 }
41600 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41601 {
41602 PyThreadState* __tstate = wxPyBeginAllowThreads();
41603 (arg1)->Detach();
41604 wxPyEndAllowThreads(__tstate);
41605 if (PyErr_Occurred()) SWIG_fail;
41606 }
41607 resultobj = SWIG_Py_Void();
41608 return resultobj;
41609 fail:
41610 return NULL;
41611 }
41612
41613
41614 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41615 PyObject *resultobj = 0;
41616 bool arg1 ;
41617 bool val1 ;
41618 int ecode1 = 0 ;
41619 PyObject * obj0 = 0 ;
41620 char * kwnames[] = {
41621 (char *) "enable", NULL
41622 };
41623
41624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41625 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41626 if (!SWIG_IsOK(ecode1)) {
41627 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41628 }
41629 arg1 = static_cast< bool >(val1);
41630 {
41631 PyThreadState* __tstate = wxPyBeginAllowThreads();
41632 wxMenuBar_SetAutoWindowMenu(arg1);
41633 wxPyEndAllowThreads(__tstate);
41634 if (PyErr_Occurred()) SWIG_fail;
41635 }
41636 resultobj = SWIG_Py_Void();
41637 return resultobj;
41638 fail:
41639 return NULL;
41640 }
41641
41642
41643 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41644 PyObject *resultobj = 0;
41645 bool result;
41646
41647 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41648 {
41649 PyThreadState* __tstate = wxPyBeginAllowThreads();
41650 result = (bool)wxMenuBar_GetAutoWindowMenu();
41651 wxPyEndAllowThreads(__tstate);
41652 if (PyErr_Occurred()) SWIG_fail;
41653 }
41654 {
41655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41656 }
41657 return resultobj;
41658 fail:
41659 return NULL;
41660 }
41661
41662
41663 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41664 PyObject *obj;
41665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41666 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41667 return SWIG_Py_Void();
41668 }
41669
41670 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41671 return SWIG_Python_InitShadowInstance(args);
41672 }
41673
41674 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41675 PyObject *resultobj = 0;
41676 wxMenu *arg1 = (wxMenu *) NULL ;
41677 int arg2 = (int) wxID_ANY ;
41678 wxString const &arg3_defvalue = wxPyEmptyString ;
41679 wxString *arg3 = (wxString *) &arg3_defvalue ;
41680 wxString const &arg4_defvalue = wxPyEmptyString ;
41681 wxString *arg4 = (wxString *) &arg4_defvalue ;
41682 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41683 wxMenu *arg6 = (wxMenu *) NULL ;
41684 wxMenuItem *result = 0 ;
41685 void *argp1 = 0 ;
41686 int res1 = 0 ;
41687 int val2 ;
41688 int ecode2 = 0 ;
41689 bool temp3 = false ;
41690 bool temp4 = false ;
41691 int val5 ;
41692 int ecode5 = 0 ;
41693 void *argp6 = 0 ;
41694 int res6 = 0 ;
41695 PyObject * obj0 = 0 ;
41696 PyObject * obj1 = 0 ;
41697 PyObject * obj2 = 0 ;
41698 PyObject * obj3 = 0 ;
41699 PyObject * obj4 = 0 ;
41700 PyObject * obj5 = 0 ;
41701 char * kwnames[] = {
41702 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41703 };
41704
41705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41706 if (obj0) {
41707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41708 if (!SWIG_IsOK(res1)) {
41709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41710 }
41711 arg1 = reinterpret_cast< wxMenu * >(argp1);
41712 }
41713 if (obj1) {
41714 ecode2 = SWIG_AsVal_int(obj1, &val2);
41715 if (!SWIG_IsOK(ecode2)) {
41716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41717 }
41718 arg2 = static_cast< int >(val2);
41719 }
41720 if (obj2) {
41721 {
41722 arg3 = wxString_in_helper(obj2);
41723 if (arg3 == NULL) SWIG_fail;
41724 temp3 = true;
41725 }
41726 }
41727 if (obj3) {
41728 {
41729 arg4 = wxString_in_helper(obj3);
41730 if (arg4 == NULL) SWIG_fail;
41731 temp4 = true;
41732 }
41733 }
41734 if (obj4) {
41735 ecode5 = SWIG_AsVal_int(obj4, &val5);
41736 if (!SWIG_IsOK(ecode5)) {
41737 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
41738 }
41739 arg5 = static_cast< wxItemKind >(val5);
41740 }
41741 if (obj5) {
41742 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
41743 if (!SWIG_IsOK(res6)) {
41744 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
41745 }
41746 arg6 = reinterpret_cast< wxMenu * >(argp6);
41747 }
41748 {
41749 PyThreadState* __tstate = wxPyBeginAllowThreads();
41750 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
41751 wxPyEndAllowThreads(__tstate);
41752 if (PyErr_Occurred()) SWIG_fail;
41753 }
41754 {
41755 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
41756 }
41757 {
41758 if (temp3)
41759 delete arg3;
41760 }
41761 {
41762 if (temp4)
41763 delete arg4;
41764 }
41765 return resultobj;
41766 fail:
41767 {
41768 if (temp3)
41769 delete arg3;
41770 }
41771 {
41772 if (temp4)
41773 delete arg4;
41774 }
41775 return NULL;
41776 }
41777
41778
41779 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41780 PyObject *resultobj = 0;
41781 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41782 void *argp1 = 0 ;
41783 int res1 = 0 ;
41784 PyObject *swig_obj[1] ;
41785
41786 if (!args) SWIG_fail;
41787 swig_obj[0] = args;
41788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
41789 if (!SWIG_IsOK(res1)) {
41790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41791 }
41792 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41793 {
41794 PyThreadState* __tstate = wxPyBeginAllowThreads();
41795 delete arg1;
41796
41797 wxPyEndAllowThreads(__tstate);
41798 if (PyErr_Occurred()) SWIG_fail;
41799 }
41800 resultobj = SWIG_Py_Void();
41801 return resultobj;
41802 fail:
41803 return NULL;
41804 }
41805
41806
41807 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41808 PyObject *resultobj = 0;
41809 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41810 wxMenu *result = 0 ;
41811 void *argp1 = 0 ;
41812 int res1 = 0 ;
41813 PyObject *swig_obj[1] ;
41814
41815 if (!args) SWIG_fail;
41816 swig_obj[0] = args;
41817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41818 if (!SWIG_IsOK(res1)) {
41819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41820 }
41821 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41822 {
41823 PyThreadState* __tstate = wxPyBeginAllowThreads();
41824 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
41825 wxPyEndAllowThreads(__tstate);
41826 if (PyErr_Occurred()) SWIG_fail;
41827 }
41828 {
41829 resultobj = wxPyMake_wxObject(result, 0);
41830 }
41831 return resultobj;
41832 fail:
41833 return NULL;
41834 }
41835
41836
41837 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41838 PyObject *resultobj = 0;
41839 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41840 wxMenu *arg2 = (wxMenu *) 0 ;
41841 void *argp1 = 0 ;
41842 int res1 = 0 ;
41843 void *argp2 = 0 ;
41844 int res2 = 0 ;
41845 PyObject * obj0 = 0 ;
41846 PyObject * obj1 = 0 ;
41847 char * kwnames[] = {
41848 (char *) "self",(char *) "menu", NULL
41849 };
41850
41851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41853 if (!SWIG_IsOK(res1)) {
41854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41855 }
41856 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41857 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41858 if (!SWIG_IsOK(res2)) {
41859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
41860 }
41861 arg2 = reinterpret_cast< wxMenu * >(argp2);
41862 {
41863 PyThreadState* __tstate = wxPyBeginAllowThreads();
41864 (arg1)->SetMenu(arg2);
41865 wxPyEndAllowThreads(__tstate);
41866 if (PyErr_Occurred()) SWIG_fail;
41867 }
41868 resultobj = SWIG_Py_Void();
41869 return resultobj;
41870 fail:
41871 return NULL;
41872 }
41873
41874
41875 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41876 PyObject *resultobj = 0;
41877 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41878 int arg2 ;
41879 void *argp1 = 0 ;
41880 int res1 = 0 ;
41881 int val2 ;
41882 int ecode2 = 0 ;
41883 PyObject * obj0 = 0 ;
41884 PyObject * obj1 = 0 ;
41885 char * kwnames[] = {
41886 (char *) "self",(char *) "id", NULL
41887 };
41888
41889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
41890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41891 if (!SWIG_IsOK(res1)) {
41892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41893 }
41894 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41895 ecode2 = SWIG_AsVal_int(obj1, &val2);
41896 if (!SWIG_IsOK(ecode2)) {
41897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
41898 }
41899 arg2 = static_cast< int >(val2);
41900 {
41901 PyThreadState* __tstate = wxPyBeginAllowThreads();
41902 (arg1)->SetId(arg2);
41903 wxPyEndAllowThreads(__tstate);
41904 if (PyErr_Occurred()) SWIG_fail;
41905 }
41906 resultobj = SWIG_Py_Void();
41907 return resultobj;
41908 fail:
41909 return NULL;
41910 }
41911
41912
41913 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41914 PyObject *resultobj = 0;
41915 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41916 int result;
41917 void *argp1 = 0 ;
41918 int res1 = 0 ;
41919 PyObject *swig_obj[1] ;
41920
41921 if (!args) SWIG_fail;
41922 swig_obj[0] = args;
41923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41924 if (!SWIG_IsOK(res1)) {
41925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41926 }
41927 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41928 {
41929 PyThreadState* __tstate = wxPyBeginAllowThreads();
41930 result = (int)((wxMenuItem const *)arg1)->GetId();
41931 wxPyEndAllowThreads(__tstate);
41932 if (PyErr_Occurred()) SWIG_fail;
41933 }
41934 resultobj = SWIG_From_int(static_cast< int >(result));
41935 return resultobj;
41936 fail:
41937 return NULL;
41938 }
41939
41940
41941 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41942 PyObject *resultobj = 0;
41943 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41944 bool result;
41945 void *argp1 = 0 ;
41946 int res1 = 0 ;
41947 PyObject *swig_obj[1] ;
41948
41949 if (!args) SWIG_fail;
41950 swig_obj[0] = args;
41951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41952 if (!SWIG_IsOK(res1)) {
41953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41954 }
41955 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41956 {
41957 PyThreadState* __tstate = wxPyBeginAllowThreads();
41958 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
41959 wxPyEndAllowThreads(__tstate);
41960 if (PyErr_Occurred()) SWIG_fail;
41961 }
41962 {
41963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41964 }
41965 return resultobj;
41966 fail:
41967 return NULL;
41968 }
41969
41970
41971 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41972 PyObject *resultobj = 0;
41973 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41974 wxString *arg2 = 0 ;
41975 void *argp1 = 0 ;
41976 int res1 = 0 ;
41977 bool temp2 = false ;
41978 PyObject * obj0 = 0 ;
41979 PyObject * obj1 = 0 ;
41980 char * kwnames[] = {
41981 (char *) "self",(char *) "str", NULL
41982 };
41983
41984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
41985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41986 if (!SWIG_IsOK(res1)) {
41987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41988 }
41989 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41990 {
41991 arg2 = wxString_in_helper(obj1);
41992 if (arg2 == NULL) SWIG_fail;
41993 temp2 = true;
41994 }
41995 {
41996 PyThreadState* __tstate = wxPyBeginAllowThreads();
41997 (arg1)->SetText((wxString const &)*arg2);
41998 wxPyEndAllowThreads(__tstate);
41999 if (PyErr_Occurred()) SWIG_fail;
42000 }
42001 resultobj = SWIG_Py_Void();
42002 {
42003 if (temp2)
42004 delete arg2;
42005 }
42006 return resultobj;
42007 fail:
42008 {
42009 if (temp2)
42010 delete arg2;
42011 }
42012 return NULL;
42013 }
42014
42015
42016 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42017 PyObject *resultobj = 0;
42018 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42019 wxString result;
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_wxMenuItem, 0 | 0 );
42027 if (!SWIG_IsOK(res1)) {
42028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42029 }
42030 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42031 {
42032 PyThreadState* __tstate = wxPyBeginAllowThreads();
42033 result = ((wxMenuItem const *)arg1)->GetLabel();
42034 wxPyEndAllowThreads(__tstate);
42035 if (PyErr_Occurred()) SWIG_fail;
42036 }
42037 {
42038 #if wxUSE_UNICODE
42039 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42040 #else
42041 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42042 #endif
42043 }
42044 return resultobj;
42045 fail:
42046 return NULL;
42047 }
42048
42049
42050 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42051 PyObject *resultobj = 0;
42052 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42053 wxString *result = 0 ;
42054 void *argp1 = 0 ;
42055 int res1 = 0 ;
42056 PyObject *swig_obj[1] ;
42057
42058 if (!args) SWIG_fail;
42059 swig_obj[0] = args;
42060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42061 if (!SWIG_IsOK(res1)) {
42062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42063 }
42064 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42065 {
42066 PyThreadState* __tstate = wxPyBeginAllowThreads();
42067 {
42068 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42069 result = (wxString *) &_result_ref;
42070 }
42071 wxPyEndAllowThreads(__tstate);
42072 if (PyErr_Occurred()) SWIG_fail;
42073 }
42074 {
42075 #if wxUSE_UNICODE
42076 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42077 #else
42078 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42079 #endif
42080 }
42081 return resultobj;
42082 fail:
42083 return NULL;
42084 }
42085
42086
42087 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42088 PyObject *resultobj = 0;
42089 wxString *arg1 = 0 ;
42090 wxString result;
42091 bool temp1 = false ;
42092 PyObject * obj0 = 0 ;
42093 char * kwnames[] = {
42094 (char *) "text", NULL
42095 };
42096
42097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42098 {
42099 arg1 = wxString_in_helper(obj0);
42100 if (arg1 == NULL) SWIG_fail;
42101 temp1 = true;
42102 }
42103 {
42104 PyThreadState* __tstate = wxPyBeginAllowThreads();
42105 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42106 wxPyEndAllowThreads(__tstate);
42107 if (PyErr_Occurred()) SWIG_fail;
42108 }
42109 {
42110 #if wxUSE_UNICODE
42111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42112 #else
42113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42114 #endif
42115 }
42116 {
42117 if (temp1)
42118 delete arg1;
42119 }
42120 return resultobj;
42121 fail:
42122 {
42123 if (temp1)
42124 delete arg1;
42125 }
42126 return NULL;
42127 }
42128
42129
42130 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42131 PyObject *resultobj = 0;
42132 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42133 wxItemKind result;
42134 void *argp1 = 0 ;
42135 int res1 = 0 ;
42136 PyObject *swig_obj[1] ;
42137
42138 if (!args) SWIG_fail;
42139 swig_obj[0] = args;
42140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42141 if (!SWIG_IsOK(res1)) {
42142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42143 }
42144 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42145 {
42146 PyThreadState* __tstate = wxPyBeginAllowThreads();
42147 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42148 wxPyEndAllowThreads(__tstate);
42149 if (PyErr_Occurred()) SWIG_fail;
42150 }
42151 resultobj = SWIG_From_int(static_cast< int >(result));
42152 return resultobj;
42153 fail:
42154 return NULL;
42155 }
42156
42157
42158 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42159 PyObject *resultobj = 0;
42160 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42161 wxItemKind arg2 ;
42162 void *argp1 = 0 ;
42163 int res1 = 0 ;
42164 int val2 ;
42165 int ecode2 = 0 ;
42166 PyObject * obj0 = 0 ;
42167 PyObject * obj1 = 0 ;
42168 char * kwnames[] = {
42169 (char *) "self",(char *) "kind", NULL
42170 };
42171
42172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42174 if (!SWIG_IsOK(res1)) {
42175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42176 }
42177 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42178 ecode2 = SWIG_AsVal_int(obj1, &val2);
42179 if (!SWIG_IsOK(ecode2)) {
42180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42181 }
42182 arg2 = static_cast< wxItemKind >(val2);
42183 {
42184 PyThreadState* __tstate = wxPyBeginAllowThreads();
42185 (arg1)->SetKind(arg2);
42186 wxPyEndAllowThreads(__tstate);
42187 if (PyErr_Occurred()) SWIG_fail;
42188 }
42189 resultobj = SWIG_Py_Void();
42190 return resultobj;
42191 fail:
42192 return NULL;
42193 }
42194
42195
42196 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42197 PyObject *resultobj = 0;
42198 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42199 bool arg2 ;
42200 void *argp1 = 0 ;
42201 int res1 = 0 ;
42202 bool val2 ;
42203 int ecode2 = 0 ;
42204 PyObject * obj0 = 0 ;
42205 PyObject * obj1 = 0 ;
42206 char * kwnames[] = {
42207 (char *) "self",(char *) "checkable", NULL
42208 };
42209
42210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42212 if (!SWIG_IsOK(res1)) {
42213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42214 }
42215 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42216 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42217 if (!SWIG_IsOK(ecode2)) {
42218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42219 }
42220 arg2 = static_cast< bool >(val2);
42221 {
42222 PyThreadState* __tstate = wxPyBeginAllowThreads();
42223 (arg1)->SetCheckable(arg2);
42224 wxPyEndAllowThreads(__tstate);
42225 if (PyErr_Occurred()) SWIG_fail;
42226 }
42227 resultobj = SWIG_Py_Void();
42228 return resultobj;
42229 fail:
42230 return NULL;
42231 }
42232
42233
42234 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42235 PyObject *resultobj = 0;
42236 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42237 bool result;
42238 void *argp1 = 0 ;
42239 int res1 = 0 ;
42240 PyObject *swig_obj[1] ;
42241
42242 if (!args) SWIG_fail;
42243 swig_obj[0] = args;
42244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42245 if (!SWIG_IsOK(res1)) {
42246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42247 }
42248 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42249 {
42250 PyThreadState* __tstate = wxPyBeginAllowThreads();
42251 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42252 wxPyEndAllowThreads(__tstate);
42253 if (PyErr_Occurred()) SWIG_fail;
42254 }
42255 {
42256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42257 }
42258 return resultobj;
42259 fail:
42260 return NULL;
42261 }
42262
42263
42264 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42265 PyObject *resultobj = 0;
42266 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42267 bool result;
42268 void *argp1 = 0 ;
42269 int res1 = 0 ;
42270 PyObject *swig_obj[1] ;
42271
42272 if (!args) SWIG_fail;
42273 swig_obj[0] = args;
42274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42275 if (!SWIG_IsOK(res1)) {
42276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42277 }
42278 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42279 {
42280 PyThreadState* __tstate = wxPyBeginAllowThreads();
42281 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42282 wxPyEndAllowThreads(__tstate);
42283 if (PyErr_Occurred()) SWIG_fail;
42284 }
42285 {
42286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42287 }
42288 return resultobj;
42289 fail:
42290 return NULL;
42291 }
42292
42293
42294 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42295 PyObject *resultobj = 0;
42296 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42297 wxMenu *arg2 = (wxMenu *) 0 ;
42298 void *argp1 = 0 ;
42299 int res1 = 0 ;
42300 void *argp2 = 0 ;
42301 int res2 = 0 ;
42302 PyObject * obj0 = 0 ;
42303 PyObject * obj1 = 0 ;
42304 char * kwnames[] = {
42305 (char *) "self",(char *) "menu", NULL
42306 };
42307
42308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42310 if (!SWIG_IsOK(res1)) {
42311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42312 }
42313 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42314 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42315 if (!SWIG_IsOK(res2)) {
42316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42317 }
42318 arg2 = reinterpret_cast< wxMenu * >(argp2);
42319 {
42320 PyThreadState* __tstate = wxPyBeginAllowThreads();
42321 (arg1)->SetSubMenu(arg2);
42322 wxPyEndAllowThreads(__tstate);
42323 if (PyErr_Occurred()) SWIG_fail;
42324 }
42325 resultobj = SWIG_Py_Void();
42326 return resultobj;
42327 fail:
42328 return NULL;
42329 }
42330
42331
42332 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42333 PyObject *resultobj = 0;
42334 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42335 wxMenu *result = 0 ;
42336 void *argp1 = 0 ;
42337 int res1 = 0 ;
42338 PyObject *swig_obj[1] ;
42339
42340 if (!args) SWIG_fail;
42341 swig_obj[0] = args;
42342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42343 if (!SWIG_IsOK(res1)) {
42344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42345 }
42346 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42347 {
42348 PyThreadState* __tstate = wxPyBeginAllowThreads();
42349 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42350 wxPyEndAllowThreads(__tstate);
42351 if (PyErr_Occurred()) SWIG_fail;
42352 }
42353 {
42354 resultobj = wxPyMake_wxObject(result, 0);
42355 }
42356 return resultobj;
42357 fail:
42358 return NULL;
42359 }
42360
42361
42362 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42363 PyObject *resultobj = 0;
42364 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42365 bool arg2 = (bool) true ;
42366 void *argp1 = 0 ;
42367 int res1 = 0 ;
42368 bool val2 ;
42369 int ecode2 = 0 ;
42370 PyObject * obj0 = 0 ;
42371 PyObject * obj1 = 0 ;
42372 char * kwnames[] = {
42373 (char *) "self",(char *) "enable", NULL
42374 };
42375
42376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42378 if (!SWIG_IsOK(res1)) {
42379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42380 }
42381 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42382 if (obj1) {
42383 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42384 if (!SWIG_IsOK(ecode2)) {
42385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42386 }
42387 arg2 = static_cast< bool >(val2);
42388 }
42389 {
42390 PyThreadState* __tstate = wxPyBeginAllowThreads();
42391 (arg1)->Enable(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_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42403 PyObject *resultobj = 0;
42404 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42405 bool result;
42406 void *argp1 = 0 ;
42407 int res1 = 0 ;
42408 PyObject *swig_obj[1] ;
42409
42410 if (!args) SWIG_fail;
42411 swig_obj[0] = args;
42412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42413 if (!SWIG_IsOK(res1)) {
42414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42415 }
42416 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42417 {
42418 PyThreadState* __tstate = wxPyBeginAllowThreads();
42419 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42420 wxPyEndAllowThreads(__tstate);
42421 if (PyErr_Occurred()) SWIG_fail;
42422 }
42423 {
42424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42425 }
42426 return resultobj;
42427 fail:
42428 return NULL;
42429 }
42430
42431
42432 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42433 PyObject *resultobj = 0;
42434 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42435 bool arg2 = (bool) true ;
42436 void *argp1 = 0 ;
42437 int res1 = 0 ;
42438 bool val2 ;
42439 int ecode2 = 0 ;
42440 PyObject * obj0 = 0 ;
42441 PyObject * obj1 = 0 ;
42442 char * kwnames[] = {
42443 (char *) "self",(char *) "check", NULL
42444 };
42445
42446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42448 if (!SWIG_IsOK(res1)) {
42449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42450 }
42451 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42452 if (obj1) {
42453 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42454 if (!SWIG_IsOK(ecode2)) {
42455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42456 }
42457 arg2 = static_cast< bool >(val2);
42458 }
42459 {
42460 PyThreadState* __tstate = wxPyBeginAllowThreads();
42461 (arg1)->Check(arg2);
42462 wxPyEndAllowThreads(__tstate);
42463 if (PyErr_Occurred()) SWIG_fail;
42464 }
42465 resultobj = SWIG_Py_Void();
42466 return resultobj;
42467 fail:
42468 return NULL;
42469 }
42470
42471
42472 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42473 PyObject *resultobj = 0;
42474 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42475 bool result;
42476 void *argp1 = 0 ;
42477 int res1 = 0 ;
42478 PyObject *swig_obj[1] ;
42479
42480 if (!args) SWIG_fail;
42481 swig_obj[0] = args;
42482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42483 if (!SWIG_IsOK(res1)) {
42484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42485 }
42486 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42487 {
42488 PyThreadState* __tstate = wxPyBeginAllowThreads();
42489 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42490 wxPyEndAllowThreads(__tstate);
42491 if (PyErr_Occurred()) SWIG_fail;
42492 }
42493 {
42494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42495 }
42496 return resultobj;
42497 fail:
42498 return NULL;
42499 }
42500
42501
42502 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42503 PyObject *resultobj = 0;
42504 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42505 void *argp1 = 0 ;
42506 int res1 = 0 ;
42507 PyObject *swig_obj[1] ;
42508
42509 if (!args) SWIG_fail;
42510 swig_obj[0] = args;
42511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42512 if (!SWIG_IsOK(res1)) {
42513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42514 }
42515 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42516 {
42517 PyThreadState* __tstate = wxPyBeginAllowThreads();
42518 (arg1)->Toggle();
42519 wxPyEndAllowThreads(__tstate);
42520 if (PyErr_Occurred()) SWIG_fail;
42521 }
42522 resultobj = SWIG_Py_Void();
42523 return resultobj;
42524 fail:
42525 return NULL;
42526 }
42527
42528
42529 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42530 PyObject *resultobj = 0;
42531 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42532 wxString *arg2 = 0 ;
42533 void *argp1 = 0 ;
42534 int res1 = 0 ;
42535 bool temp2 = false ;
42536 PyObject * obj0 = 0 ;
42537 PyObject * obj1 = 0 ;
42538 char * kwnames[] = {
42539 (char *) "self",(char *) "str", NULL
42540 };
42541
42542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42544 if (!SWIG_IsOK(res1)) {
42545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42546 }
42547 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42548 {
42549 arg2 = wxString_in_helper(obj1);
42550 if (arg2 == NULL) SWIG_fail;
42551 temp2 = true;
42552 }
42553 {
42554 PyThreadState* __tstate = wxPyBeginAllowThreads();
42555 (arg1)->SetHelp((wxString const &)*arg2);
42556 wxPyEndAllowThreads(__tstate);
42557 if (PyErr_Occurred()) SWIG_fail;
42558 }
42559 resultobj = SWIG_Py_Void();
42560 {
42561 if (temp2)
42562 delete arg2;
42563 }
42564 return resultobj;
42565 fail:
42566 {
42567 if (temp2)
42568 delete arg2;
42569 }
42570 return NULL;
42571 }
42572
42573
42574 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42575 PyObject *resultobj = 0;
42576 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42577 wxString *result = 0 ;
42578 void *argp1 = 0 ;
42579 int res1 = 0 ;
42580 PyObject *swig_obj[1] ;
42581
42582 if (!args) SWIG_fail;
42583 swig_obj[0] = args;
42584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42585 if (!SWIG_IsOK(res1)) {
42586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42587 }
42588 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42589 {
42590 PyThreadState* __tstate = wxPyBeginAllowThreads();
42591 {
42592 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42593 result = (wxString *) &_result_ref;
42594 }
42595 wxPyEndAllowThreads(__tstate);
42596 if (PyErr_Occurred()) SWIG_fail;
42597 }
42598 {
42599 #if wxUSE_UNICODE
42600 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42601 #else
42602 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42603 #endif
42604 }
42605 return resultobj;
42606 fail:
42607 return NULL;
42608 }
42609
42610
42611 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42612 PyObject *resultobj = 0;
42613 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42614 wxAcceleratorEntry *result = 0 ;
42615 void *argp1 = 0 ;
42616 int res1 = 0 ;
42617 PyObject *swig_obj[1] ;
42618
42619 if (!args) SWIG_fail;
42620 swig_obj[0] = args;
42621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42622 if (!SWIG_IsOK(res1)) {
42623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42624 }
42625 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42626 {
42627 PyThreadState* __tstate = wxPyBeginAllowThreads();
42628 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42629 wxPyEndAllowThreads(__tstate);
42630 if (PyErr_Occurred()) SWIG_fail;
42631 }
42632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42633 return resultobj;
42634 fail:
42635 return NULL;
42636 }
42637
42638
42639 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42640 PyObject *resultobj = 0;
42641 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42642 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42643 void *argp1 = 0 ;
42644 int res1 = 0 ;
42645 void *argp2 = 0 ;
42646 int res2 = 0 ;
42647 PyObject * obj0 = 0 ;
42648 PyObject * obj1 = 0 ;
42649 char * kwnames[] = {
42650 (char *) "self",(char *) "accel", NULL
42651 };
42652
42653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42655 if (!SWIG_IsOK(res1)) {
42656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42657 }
42658 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42660 if (!SWIG_IsOK(res2)) {
42661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42662 }
42663 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42664 {
42665 PyThreadState* __tstate = wxPyBeginAllowThreads();
42666 (arg1)->SetAccel(arg2);
42667 wxPyEndAllowThreads(__tstate);
42668 if (PyErr_Occurred()) SWIG_fail;
42669 }
42670 resultobj = SWIG_Py_Void();
42671 return resultobj;
42672 fail:
42673 return NULL;
42674 }
42675
42676
42677 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42678 PyObject *resultobj = 0;
42679 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42680 wxBitmap *arg2 = 0 ;
42681 void *argp1 = 0 ;
42682 int res1 = 0 ;
42683 void *argp2 = 0 ;
42684 int res2 = 0 ;
42685 PyObject * obj0 = 0 ;
42686 PyObject * obj1 = 0 ;
42687 char * kwnames[] = {
42688 (char *) "self",(char *) "bitmap", NULL
42689 };
42690
42691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42693 if (!SWIG_IsOK(res1)) {
42694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42695 }
42696 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42697 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42698 if (!SWIG_IsOK(res2)) {
42699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42700 }
42701 if (!argp2) {
42702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42703 }
42704 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42705 {
42706 PyThreadState* __tstate = wxPyBeginAllowThreads();
42707 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42708 wxPyEndAllowThreads(__tstate);
42709 if (PyErr_Occurred()) SWIG_fail;
42710 }
42711 resultobj = SWIG_Py_Void();
42712 return resultobj;
42713 fail:
42714 return NULL;
42715 }
42716
42717
42718 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42719 PyObject *resultobj = 0;
42720 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42721 wxBitmap *result = 0 ;
42722 void *argp1 = 0 ;
42723 int res1 = 0 ;
42724 PyObject *swig_obj[1] ;
42725
42726 if (!args) SWIG_fail;
42727 swig_obj[0] = args;
42728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42729 if (!SWIG_IsOK(res1)) {
42730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42731 }
42732 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42733 {
42734 PyThreadState* __tstate = wxPyBeginAllowThreads();
42735 {
42736 wxBitmap const &_result_ref = (arg1)->GetBitmap();
42737 result = (wxBitmap *) &_result_ref;
42738 }
42739 wxPyEndAllowThreads(__tstate);
42740 if (PyErr_Occurred()) SWIG_fail;
42741 }
42742 {
42743 wxBitmap* resultptr = new wxBitmap(*result);
42744 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
42745 }
42746 return resultobj;
42747 fail:
42748 return NULL;
42749 }
42750
42751
42752 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42753 PyObject *resultobj = 0;
42754 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42755 wxFont *arg2 = 0 ;
42756 void *argp1 = 0 ;
42757 int res1 = 0 ;
42758 void *argp2 = 0 ;
42759 int res2 = 0 ;
42760 PyObject * obj0 = 0 ;
42761 PyObject * obj1 = 0 ;
42762 char * kwnames[] = {
42763 (char *) "self",(char *) "font", NULL
42764 };
42765
42766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
42767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42768 if (!SWIG_IsOK(res1)) {
42769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42770 }
42771 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42772 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
42773 if (!SWIG_IsOK(res2)) {
42774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42775 }
42776 if (!argp2) {
42777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42778 }
42779 arg2 = reinterpret_cast< wxFont * >(argp2);
42780 {
42781 PyThreadState* __tstate = wxPyBeginAllowThreads();
42782 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
42783 wxPyEndAllowThreads(__tstate);
42784 if (PyErr_Occurred()) SWIG_fail;
42785 }
42786 resultobj = SWIG_Py_Void();
42787 return resultobj;
42788 fail:
42789 return NULL;
42790 }
42791
42792
42793 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42794 PyObject *resultobj = 0;
42795 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42796 wxFont result;
42797 void *argp1 = 0 ;
42798 int res1 = 0 ;
42799 PyObject *swig_obj[1] ;
42800
42801 if (!args) SWIG_fail;
42802 swig_obj[0] = args;
42803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42804 if (!SWIG_IsOK(res1)) {
42805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42806 }
42807 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42808 {
42809 PyThreadState* __tstate = wxPyBeginAllowThreads();
42810 result = wxMenuItem_GetFont(arg1);
42811 wxPyEndAllowThreads(__tstate);
42812 if (PyErr_Occurred()) SWIG_fail;
42813 }
42814 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
42815 return resultobj;
42816 fail:
42817 return NULL;
42818 }
42819
42820
42821 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42822 PyObject *resultobj = 0;
42823 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42824 wxColour *arg2 = 0 ;
42825 void *argp1 = 0 ;
42826 int res1 = 0 ;
42827 wxColour temp2 ;
42828 PyObject * obj0 = 0 ;
42829 PyObject * obj1 = 0 ;
42830 char * kwnames[] = {
42831 (char *) "self",(char *) "colText", NULL
42832 };
42833
42834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
42835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42836 if (!SWIG_IsOK(res1)) {
42837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42838 }
42839 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42840 {
42841 arg2 = &temp2;
42842 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
42843 }
42844 {
42845 PyThreadState* __tstate = wxPyBeginAllowThreads();
42846 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
42847 wxPyEndAllowThreads(__tstate);
42848 if (PyErr_Occurred()) SWIG_fail;
42849 }
42850 resultobj = SWIG_Py_Void();
42851 return resultobj;
42852 fail:
42853 return NULL;
42854 }
42855
42856
42857 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42858 PyObject *resultobj = 0;
42859 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42860 wxColour result;
42861 void *argp1 = 0 ;
42862 int res1 = 0 ;
42863 PyObject *swig_obj[1] ;
42864
42865 if (!args) SWIG_fail;
42866 swig_obj[0] = args;
42867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42868 if (!SWIG_IsOK(res1)) {
42869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42870 }
42871 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42872 {
42873 PyThreadState* __tstate = wxPyBeginAllowThreads();
42874 result = wxMenuItem_GetTextColour(arg1);
42875 wxPyEndAllowThreads(__tstate);
42876 if (PyErr_Occurred()) SWIG_fail;
42877 }
42878 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
42879 return resultobj;
42880 fail:
42881 return NULL;
42882 }
42883
42884
42885 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42886 PyObject *resultobj = 0;
42887 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42888 wxColour *arg2 = 0 ;
42889 void *argp1 = 0 ;
42890 int res1 = 0 ;
42891 wxColour temp2 ;
42892 PyObject * obj0 = 0 ;
42893 PyObject * obj1 = 0 ;
42894 char * kwnames[] = {
42895 (char *) "self",(char *) "colBack", NULL
42896 };
42897
42898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
42899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42900 if (!SWIG_IsOK(res1)) {
42901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42902 }
42903 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42904 {
42905 arg2 = &temp2;
42906 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
42907 }
42908 {
42909 PyThreadState* __tstate = wxPyBeginAllowThreads();
42910 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
42911 wxPyEndAllowThreads(__tstate);
42912 if (PyErr_Occurred()) SWIG_fail;
42913 }
42914 resultobj = SWIG_Py_Void();
42915 return resultobj;
42916 fail:
42917 return NULL;
42918 }
42919
42920
42921 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42922 PyObject *resultobj = 0;
42923 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42924 wxColour result;
42925 void *argp1 = 0 ;
42926 int res1 = 0 ;
42927 PyObject *swig_obj[1] ;
42928
42929 if (!args) SWIG_fail;
42930 swig_obj[0] = args;
42931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42932 if (!SWIG_IsOK(res1)) {
42933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42934 }
42935 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42936 {
42937 PyThreadState* __tstate = wxPyBeginAllowThreads();
42938 result = wxMenuItem_GetBackgroundColour(arg1);
42939 wxPyEndAllowThreads(__tstate);
42940 if (PyErr_Occurred()) SWIG_fail;
42941 }
42942 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
42943 return resultobj;
42944 fail:
42945 return NULL;
42946 }
42947
42948
42949 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42950 PyObject *resultobj = 0;
42951 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42952 wxBitmap *arg2 = 0 ;
42953 wxBitmap const &arg3_defvalue = wxNullBitmap ;
42954 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
42955 void *argp1 = 0 ;
42956 int res1 = 0 ;
42957 void *argp2 = 0 ;
42958 int res2 = 0 ;
42959 void *argp3 = 0 ;
42960 int res3 = 0 ;
42961 PyObject * obj0 = 0 ;
42962 PyObject * obj1 = 0 ;
42963 PyObject * obj2 = 0 ;
42964 char * kwnames[] = {
42965 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
42966 };
42967
42968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42970 if (!SWIG_IsOK(res1)) {
42971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42972 }
42973 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42974 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42975 if (!SWIG_IsOK(res2)) {
42976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42977 }
42978 if (!argp2) {
42979 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42980 }
42981 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42982 if (obj2) {
42983 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
42984 if (!SWIG_IsOK(res3)) {
42985 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
42986 }
42987 if (!argp3) {
42988 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
42989 }
42990 arg3 = reinterpret_cast< wxBitmap * >(argp3);
42991 }
42992 {
42993 PyThreadState* __tstate = wxPyBeginAllowThreads();
42994 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
42995 wxPyEndAllowThreads(__tstate);
42996 if (PyErr_Occurred()) SWIG_fail;
42997 }
42998 resultobj = SWIG_Py_Void();
42999 return resultobj;
43000 fail:
43001 return NULL;
43002 }
43003
43004
43005 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43006 PyObject *resultobj = 0;
43007 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43008 wxBitmap *arg2 = 0 ;
43009 void *argp1 = 0 ;
43010 int res1 = 0 ;
43011 void *argp2 = 0 ;
43012 int res2 = 0 ;
43013 PyObject * obj0 = 0 ;
43014 PyObject * obj1 = 0 ;
43015 char * kwnames[] = {
43016 (char *) "self",(char *) "bmpDisabled", NULL
43017 };
43018
43019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43021 if (!SWIG_IsOK(res1)) {
43022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43023 }
43024 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43025 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43026 if (!SWIG_IsOK(res2)) {
43027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43028 }
43029 if (!argp2) {
43030 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43031 }
43032 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43033 {
43034 PyThreadState* __tstate = wxPyBeginAllowThreads();
43035 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43036 wxPyEndAllowThreads(__tstate);
43037 if (PyErr_Occurred()) SWIG_fail;
43038 }
43039 resultobj = SWIG_Py_Void();
43040 return resultobj;
43041 fail:
43042 return NULL;
43043 }
43044
43045
43046 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43047 PyObject *resultobj = 0;
43048 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43049 wxBitmap *result = 0 ;
43050 void *argp1 = 0 ;
43051 int res1 = 0 ;
43052 PyObject *swig_obj[1] ;
43053
43054 if (!args) SWIG_fail;
43055 swig_obj[0] = args;
43056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43057 if (!SWIG_IsOK(res1)) {
43058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43059 }
43060 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43061 {
43062 PyThreadState* __tstate = wxPyBeginAllowThreads();
43063 {
43064 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43065 result = (wxBitmap *) &_result_ref;
43066 }
43067 wxPyEndAllowThreads(__tstate);
43068 if (PyErr_Occurred()) SWIG_fail;
43069 }
43070 {
43071 wxBitmap* resultptr = new wxBitmap(*result);
43072 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43073 }
43074 return resultobj;
43075 fail:
43076 return NULL;
43077 }
43078
43079
43080 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43081 PyObject *resultobj = 0;
43082 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43083 int arg2 ;
43084 void *argp1 = 0 ;
43085 int res1 = 0 ;
43086 int val2 ;
43087 int ecode2 = 0 ;
43088 PyObject * obj0 = 0 ;
43089 PyObject * obj1 = 0 ;
43090 char * kwnames[] = {
43091 (char *) "self",(char *) "nWidth", NULL
43092 };
43093
43094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43096 if (!SWIG_IsOK(res1)) {
43097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43098 }
43099 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43100 ecode2 = SWIG_AsVal_int(obj1, &val2);
43101 if (!SWIG_IsOK(ecode2)) {
43102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43103 }
43104 arg2 = static_cast< int >(val2);
43105 {
43106 PyThreadState* __tstate = wxPyBeginAllowThreads();
43107 wxMenuItem_SetMarginWidth(arg1,arg2);
43108 wxPyEndAllowThreads(__tstate);
43109 if (PyErr_Occurred()) SWIG_fail;
43110 }
43111 resultobj = SWIG_Py_Void();
43112 return resultobj;
43113 fail:
43114 return NULL;
43115 }
43116
43117
43118 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43119 PyObject *resultobj = 0;
43120 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43121 int result;
43122 void *argp1 = 0 ;
43123 int res1 = 0 ;
43124 PyObject *swig_obj[1] ;
43125
43126 if (!args) SWIG_fail;
43127 swig_obj[0] = args;
43128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43129 if (!SWIG_IsOK(res1)) {
43130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43131 }
43132 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43133 {
43134 PyThreadState* __tstate = wxPyBeginAllowThreads();
43135 result = (int)wxMenuItem_GetMarginWidth(arg1);
43136 wxPyEndAllowThreads(__tstate);
43137 if (PyErr_Occurred()) SWIG_fail;
43138 }
43139 resultobj = SWIG_From_int(static_cast< int >(result));
43140 return resultobj;
43141 fail:
43142 return NULL;
43143 }
43144
43145
43146 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43147 PyObject *resultobj = 0;
43148 int result;
43149
43150 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43151 {
43152 PyThreadState* __tstate = wxPyBeginAllowThreads();
43153 result = (int)wxMenuItem_GetDefaultMarginWidth();
43154 wxPyEndAllowThreads(__tstate);
43155 if (PyErr_Occurred()) SWIG_fail;
43156 }
43157 resultobj = SWIG_From_int(static_cast< int >(result));
43158 return resultobj;
43159 fail:
43160 return NULL;
43161 }
43162
43163
43164 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43165 PyObject *resultobj = 0;
43166 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43167 bool result;
43168 void *argp1 = 0 ;
43169 int res1 = 0 ;
43170 PyObject *swig_obj[1] ;
43171
43172 if (!args) SWIG_fail;
43173 swig_obj[0] = args;
43174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43175 if (!SWIG_IsOK(res1)) {
43176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43177 }
43178 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43179 {
43180 PyThreadState* __tstate = wxPyBeginAllowThreads();
43181 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43182 wxPyEndAllowThreads(__tstate);
43183 if (PyErr_Occurred()) SWIG_fail;
43184 }
43185 {
43186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43187 }
43188 return resultobj;
43189 fail:
43190 return NULL;
43191 }
43192
43193
43194 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43195 PyObject *resultobj = 0;
43196 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43197 bool arg2 = (bool) true ;
43198 void *argp1 = 0 ;
43199 int res1 = 0 ;
43200 bool val2 ;
43201 int ecode2 = 0 ;
43202 PyObject * obj0 = 0 ;
43203 PyObject * obj1 = 0 ;
43204 char * kwnames[] = {
43205 (char *) "self",(char *) "ownerDrawn", NULL
43206 };
43207
43208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43210 if (!SWIG_IsOK(res1)) {
43211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43212 }
43213 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43214 if (obj1) {
43215 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43216 if (!SWIG_IsOK(ecode2)) {
43217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43218 }
43219 arg2 = static_cast< bool >(val2);
43220 }
43221 {
43222 PyThreadState* __tstate = wxPyBeginAllowThreads();
43223 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43224 wxPyEndAllowThreads(__tstate);
43225 if (PyErr_Occurred()) SWIG_fail;
43226 }
43227 resultobj = SWIG_Py_Void();
43228 return resultobj;
43229 fail:
43230 return NULL;
43231 }
43232
43233
43234 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43235 PyObject *resultobj = 0;
43236 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43237 void *argp1 = 0 ;
43238 int res1 = 0 ;
43239 PyObject *swig_obj[1] ;
43240
43241 if (!args) SWIG_fail;
43242 swig_obj[0] = args;
43243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43244 if (!SWIG_IsOK(res1)) {
43245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43246 }
43247 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43248 {
43249 PyThreadState* __tstate = wxPyBeginAllowThreads();
43250 wxMenuItem_ResetOwnerDrawn(arg1);
43251 wxPyEndAllowThreads(__tstate);
43252 if (PyErr_Occurred()) SWIG_fail;
43253 }
43254 resultobj = SWIG_Py_Void();
43255 return resultobj;
43256 fail:
43257 return NULL;
43258 }
43259
43260
43261 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43262 PyObject *obj;
43263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43264 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43265 return SWIG_Py_Void();
43266 }
43267
43268 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43269 return SWIG_Python_InitShadowInstance(args);
43270 }
43271
43272 SWIGINTERN int ControlNameStr_set(PyObject *) {
43273 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43274 return 1;
43275 }
43276
43277
43278 SWIGINTERN PyObject *ControlNameStr_get(void) {
43279 PyObject *pyobj = 0;
43280
43281 {
43282 #if wxUSE_UNICODE
43283 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43284 #else
43285 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43286 #endif
43287 }
43288 return pyobj;
43289 }
43290
43291
43292 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43293 PyObject *resultobj = 0;
43294 wxWindow *arg1 = (wxWindow *) 0 ;
43295 int arg2 = (int) -1 ;
43296 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43297 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43298 wxSize const &arg4_defvalue = wxDefaultSize ;
43299 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43300 long arg5 = (long) 0 ;
43301 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43302 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43303 wxString const &arg7_defvalue = wxPyControlNameStr ;
43304 wxString *arg7 = (wxString *) &arg7_defvalue ;
43305 wxControl *result = 0 ;
43306 void *argp1 = 0 ;
43307 int res1 = 0 ;
43308 int val2 ;
43309 int ecode2 = 0 ;
43310 wxPoint temp3 ;
43311 wxSize temp4 ;
43312 long val5 ;
43313 int ecode5 = 0 ;
43314 void *argp6 = 0 ;
43315 int res6 = 0 ;
43316 bool temp7 = false ;
43317 PyObject * obj0 = 0 ;
43318 PyObject * obj1 = 0 ;
43319 PyObject * obj2 = 0 ;
43320 PyObject * obj3 = 0 ;
43321 PyObject * obj4 = 0 ;
43322 PyObject * obj5 = 0 ;
43323 PyObject * obj6 = 0 ;
43324 char * kwnames[] = {
43325 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43326 };
43327
43328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43330 if (!SWIG_IsOK(res1)) {
43331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43332 }
43333 arg1 = reinterpret_cast< wxWindow * >(argp1);
43334 if (obj1) {
43335 ecode2 = SWIG_AsVal_int(obj1, &val2);
43336 if (!SWIG_IsOK(ecode2)) {
43337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43338 }
43339 arg2 = static_cast< int >(val2);
43340 }
43341 if (obj2) {
43342 {
43343 arg3 = &temp3;
43344 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43345 }
43346 }
43347 if (obj3) {
43348 {
43349 arg4 = &temp4;
43350 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43351 }
43352 }
43353 if (obj4) {
43354 ecode5 = SWIG_AsVal_long(obj4, &val5);
43355 if (!SWIG_IsOK(ecode5)) {
43356 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43357 }
43358 arg5 = static_cast< long >(val5);
43359 }
43360 if (obj5) {
43361 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43362 if (!SWIG_IsOK(res6)) {
43363 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43364 }
43365 if (!argp6) {
43366 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43367 }
43368 arg6 = reinterpret_cast< wxValidator * >(argp6);
43369 }
43370 if (obj6) {
43371 {
43372 arg7 = wxString_in_helper(obj6);
43373 if (arg7 == NULL) SWIG_fail;
43374 temp7 = true;
43375 }
43376 }
43377 {
43378 if (!wxPyCheckForApp()) SWIG_fail;
43379 PyThreadState* __tstate = wxPyBeginAllowThreads();
43380 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43381 wxPyEndAllowThreads(__tstate);
43382 if (PyErr_Occurred()) SWIG_fail;
43383 }
43384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43385 {
43386 if (temp7)
43387 delete arg7;
43388 }
43389 return resultobj;
43390 fail:
43391 {
43392 if (temp7)
43393 delete arg7;
43394 }
43395 return NULL;
43396 }
43397
43398
43399 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43400 PyObject *resultobj = 0;
43401 wxControl *result = 0 ;
43402
43403 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43404 {
43405 if (!wxPyCheckForApp()) SWIG_fail;
43406 PyThreadState* __tstate = wxPyBeginAllowThreads();
43407 result = (wxControl *)new wxControl();
43408 wxPyEndAllowThreads(__tstate);
43409 if (PyErr_Occurred()) SWIG_fail;
43410 }
43411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43412 return resultobj;
43413 fail:
43414 return NULL;
43415 }
43416
43417
43418 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43419 PyObject *resultobj = 0;
43420 wxControl *arg1 = (wxControl *) 0 ;
43421 wxWindow *arg2 = (wxWindow *) 0 ;
43422 int arg3 = (int) -1 ;
43423 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43424 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43425 wxSize const &arg5_defvalue = wxDefaultSize ;
43426 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43427 long arg6 = (long) 0 ;
43428 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43429 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43430 wxString const &arg8_defvalue = wxPyControlNameStr ;
43431 wxString *arg8 = (wxString *) &arg8_defvalue ;
43432 bool result;
43433 void *argp1 = 0 ;
43434 int res1 = 0 ;
43435 void *argp2 = 0 ;
43436 int res2 = 0 ;
43437 int val3 ;
43438 int ecode3 = 0 ;
43439 wxPoint temp4 ;
43440 wxSize temp5 ;
43441 long val6 ;
43442 int ecode6 = 0 ;
43443 void *argp7 = 0 ;
43444 int res7 = 0 ;
43445 bool temp8 = false ;
43446 PyObject * obj0 = 0 ;
43447 PyObject * obj1 = 0 ;
43448 PyObject * obj2 = 0 ;
43449 PyObject * obj3 = 0 ;
43450 PyObject * obj4 = 0 ;
43451 PyObject * obj5 = 0 ;
43452 PyObject * obj6 = 0 ;
43453 PyObject * obj7 = 0 ;
43454 char * kwnames[] = {
43455 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43456 };
43457
43458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43460 if (!SWIG_IsOK(res1)) {
43461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43462 }
43463 arg1 = reinterpret_cast< wxControl * >(argp1);
43464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43465 if (!SWIG_IsOK(res2)) {
43466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43467 }
43468 arg2 = reinterpret_cast< wxWindow * >(argp2);
43469 if (obj2) {
43470 ecode3 = SWIG_AsVal_int(obj2, &val3);
43471 if (!SWIG_IsOK(ecode3)) {
43472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43473 }
43474 arg3 = static_cast< int >(val3);
43475 }
43476 if (obj3) {
43477 {
43478 arg4 = &temp4;
43479 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43480 }
43481 }
43482 if (obj4) {
43483 {
43484 arg5 = &temp5;
43485 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43486 }
43487 }
43488 if (obj5) {
43489 ecode6 = SWIG_AsVal_long(obj5, &val6);
43490 if (!SWIG_IsOK(ecode6)) {
43491 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43492 }
43493 arg6 = static_cast< long >(val6);
43494 }
43495 if (obj6) {
43496 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43497 if (!SWIG_IsOK(res7)) {
43498 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43499 }
43500 if (!argp7) {
43501 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43502 }
43503 arg7 = reinterpret_cast< wxValidator * >(argp7);
43504 }
43505 if (obj7) {
43506 {
43507 arg8 = wxString_in_helper(obj7);
43508 if (arg8 == NULL) SWIG_fail;
43509 temp8 = true;
43510 }
43511 }
43512 {
43513 PyThreadState* __tstate = wxPyBeginAllowThreads();
43514 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43515 wxPyEndAllowThreads(__tstate);
43516 if (PyErr_Occurred()) SWIG_fail;
43517 }
43518 {
43519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43520 }
43521 {
43522 if (temp8)
43523 delete arg8;
43524 }
43525 return resultobj;
43526 fail:
43527 {
43528 if (temp8)
43529 delete arg8;
43530 }
43531 return NULL;
43532 }
43533
43534
43535 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43536 PyObject *resultobj = 0;
43537 wxControl *arg1 = (wxControl *) 0 ;
43538 wxCommandEvent *arg2 = 0 ;
43539 void *argp1 = 0 ;
43540 int res1 = 0 ;
43541 void *argp2 = 0 ;
43542 int res2 = 0 ;
43543 PyObject * obj0 = 0 ;
43544 PyObject * obj1 = 0 ;
43545 char * kwnames[] = {
43546 (char *) "self",(char *) "event", NULL
43547 };
43548
43549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43551 if (!SWIG_IsOK(res1)) {
43552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43553 }
43554 arg1 = reinterpret_cast< wxControl * >(argp1);
43555 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43556 if (!SWIG_IsOK(res2)) {
43557 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43558 }
43559 if (!argp2) {
43560 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43561 }
43562 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43563 {
43564 PyThreadState* __tstate = wxPyBeginAllowThreads();
43565 (arg1)->Command(*arg2);
43566 wxPyEndAllowThreads(__tstate);
43567 if (PyErr_Occurred()) SWIG_fail;
43568 }
43569 resultobj = SWIG_Py_Void();
43570 return resultobj;
43571 fail:
43572 return NULL;
43573 }
43574
43575
43576 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43577 PyObject *resultobj = 0;
43578 wxControl *arg1 = (wxControl *) 0 ;
43579 wxString result;
43580 void *argp1 = 0 ;
43581 int res1 = 0 ;
43582 PyObject *swig_obj[1] ;
43583
43584 if (!args) SWIG_fail;
43585 swig_obj[0] = args;
43586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43587 if (!SWIG_IsOK(res1)) {
43588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43589 }
43590 arg1 = reinterpret_cast< wxControl * >(argp1);
43591 {
43592 PyThreadState* __tstate = wxPyBeginAllowThreads();
43593 result = (arg1)->GetLabel();
43594 wxPyEndAllowThreads(__tstate);
43595 if (PyErr_Occurred()) SWIG_fail;
43596 }
43597 {
43598 #if wxUSE_UNICODE
43599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43600 #else
43601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43602 #endif
43603 }
43604 return resultobj;
43605 fail:
43606 return NULL;
43607 }
43608
43609
43610 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43611 PyObject *resultobj = 0;
43612 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43613 SwigValueWrapper<wxVisualAttributes > result;
43614 int val1 ;
43615 int ecode1 = 0 ;
43616 PyObject * obj0 = 0 ;
43617 char * kwnames[] = {
43618 (char *) "variant", NULL
43619 };
43620
43621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43622 if (obj0) {
43623 ecode1 = SWIG_AsVal_int(obj0, &val1);
43624 if (!SWIG_IsOK(ecode1)) {
43625 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43626 }
43627 arg1 = static_cast< wxWindowVariant >(val1);
43628 }
43629 {
43630 if (!wxPyCheckForApp()) SWIG_fail;
43631 PyThreadState* __tstate = wxPyBeginAllowThreads();
43632 result = wxControl::GetClassDefaultAttributes(arg1);
43633 wxPyEndAllowThreads(__tstate);
43634 if (PyErr_Occurred()) SWIG_fail;
43635 }
43636 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43637 return resultobj;
43638 fail:
43639 return NULL;
43640 }
43641
43642
43643 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43644 PyObject *obj;
43645 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43646 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43647 return SWIG_Py_Void();
43648 }
43649
43650 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43651 return SWIG_Python_InitShadowInstance(args);
43652 }
43653
43654 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43655 PyObject *resultobj = 0;
43656 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43657 wxString *arg2 = 0 ;
43658 PyObject *arg3 = (PyObject *) NULL ;
43659 int result;
43660 void *argp1 = 0 ;
43661 int res1 = 0 ;
43662 bool temp2 = false ;
43663 PyObject * obj0 = 0 ;
43664 PyObject * obj1 = 0 ;
43665 PyObject * obj2 = 0 ;
43666 char * kwnames[] = {
43667 (char *) "self",(char *) "item",(char *) "clientData", NULL
43668 };
43669
43670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43672 if (!SWIG_IsOK(res1)) {
43673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43674 }
43675 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43676 {
43677 arg2 = wxString_in_helper(obj1);
43678 if (arg2 == NULL) SWIG_fail;
43679 temp2 = true;
43680 }
43681 if (obj2) {
43682 arg3 = obj2;
43683 }
43684 {
43685 PyThreadState* __tstate = wxPyBeginAllowThreads();
43686 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43687 wxPyEndAllowThreads(__tstate);
43688 if (PyErr_Occurred()) SWIG_fail;
43689 }
43690 resultobj = SWIG_From_int(static_cast< int >(result));
43691 {
43692 if (temp2)
43693 delete arg2;
43694 }
43695 return resultobj;
43696 fail:
43697 {
43698 if (temp2)
43699 delete arg2;
43700 }
43701 return NULL;
43702 }
43703
43704
43705 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43706 PyObject *resultobj = 0;
43707 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43708 wxArrayString *arg2 = 0 ;
43709 void *argp1 = 0 ;
43710 int res1 = 0 ;
43711 bool temp2 = false ;
43712 PyObject * obj0 = 0 ;
43713 PyObject * obj1 = 0 ;
43714 char * kwnames[] = {
43715 (char *) "self",(char *) "strings", NULL
43716 };
43717
43718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43720 if (!SWIG_IsOK(res1)) {
43721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43722 }
43723 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43724 {
43725 if (! PySequence_Check(obj1)) {
43726 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43727 SWIG_fail;
43728 }
43729 arg2 = new wxArrayString;
43730 temp2 = true;
43731 int i, len=PySequence_Length(obj1);
43732 for (i=0; i<len; i++) {
43733 PyObject* item = PySequence_GetItem(obj1, i);
43734 wxString* s = wxString_in_helper(item);
43735 if (PyErr_Occurred()) SWIG_fail;
43736 arg2->Add(*s);
43737 delete s;
43738 Py_DECREF(item);
43739 }
43740 }
43741 {
43742 PyThreadState* __tstate = wxPyBeginAllowThreads();
43743 (arg1)->Append((wxArrayString const &)*arg2);
43744 wxPyEndAllowThreads(__tstate);
43745 if (PyErr_Occurred()) SWIG_fail;
43746 }
43747 resultobj = SWIG_Py_Void();
43748 {
43749 if (temp2) delete arg2;
43750 }
43751 return resultobj;
43752 fail:
43753 {
43754 if (temp2) delete arg2;
43755 }
43756 return NULL;
43757 }
43758
43759
43760 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43761 PyObject *resultobj = 0;
43762 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43763 wxString *arg2 = 0 ;
43764 int arg3 ;
43765 PyObject *arg4 = (PyObject *) NULL ;
43766 int result;
43767 void *argp1 = 0 ;
43768 int res1 = 0 ;
43769 bool temp2 = false ;
43770 int val3 ;
43771 int ecode3 = 0 ;
43772 PyObject * obj0 = 0 ;
43773 PyObject * obj1 = 0 ;
43774 PyObject * obj2 = 0 ;
43775 PyObject * obj3 = 0 ;
43776 char * kwnames[] = {
43777 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
43778 };
43779
43780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43782 if (!SWIG_IsOK(res1)) {
43783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43784 }
43785 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43786 {
43787 arg2 = wxString_in_helper(obj1);
43788 if (arg2 == NULL) SWIG_fail;
43789 temp2 = true;
43790 }
43791 ecode3 = SWIG_AsVal_int(obj2, &val3);
43792 if (!SWIG_IsOK(ecode3)) {
43793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
43794 }
43795 arg3 = static_cast< int >(val3);
43796 if (obj3) {
43797 arg4 = obj3;
43798 }
43799 {
43800 PyThreadState* __tstate = wxPyBeginAllowThreads();
43801 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
43802 wxPyEndAllowThreads(__tstate);
43803 if (PyErr_Occurred()) SWIG_fail;
43804 }
43805 resultobj = SWIG_From_int(static_cast< int >(result));
43806 {
43807 if (temp2)
43808 delete arg2;
43809 }
43810 return resultobj;
43811 fail:
43812 {
43813 if (temp2)
43814 delete arg2;
43815 }
43816 return NULL;
43817 }
43818
43819
43820 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43821 PyObject *resultobj = 0;
43822 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43823 void *argp1 = 0 ;
43824 int res1 = 0 ;
43825 PyObject *swig_obj[1] ;
43826
43827 if (!args) SWIG_fail;
43828 swig_obj[0] = args;
43829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43830 if (!SWIG_IsOK(res1)) {
43831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43832 }
43833 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43834 {
43835 PyThreadState* __tstate = wxPyBeginAllowThreads();
43836 (arg1)->Clear();
43837 wxPyEndAllowThreads(__tstate);
43838 if (PyErr_Occurred()) SWIG_fail;
43839 }
43840 resultobj = SWIG_Py_Void();
43841 return resultobj;
43842 fail:
43843 return NULL;
43844 }
43845
43846
43847 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43848 PyObject *resultobj = 0;
43849 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43850 int arg2 ;
43851 void *argp1 = 0 ;
43852 int res1 = 0 ;
43853 int val2 ;
43854 int ecode2 = 0 ;
43855 PyObject * obj0 = 0 ;
43856 PyObject * obj1 = 0 ;
43857 char * kwnames[] = {
43858 (char *) "self",(char *) "n", NULL
43859 };
43860
43861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43863 if (!SWIG_IsOK(res1)) {
43864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43865 }
43866 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43867 ecode2 = SWIG_AsVal_int(obj1, &val2);
43868 if (!SWIG_IsOK(ecode2)) {
43869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
43870 }
43871 arg2 = static_cast< int >(val2);
43872 {
43873 PyThreadState* __tstate = wxPyBeginAllowThreads();
43874 (arg1)->Delete(arg2);
43875 wxPyEndAllowThreads(__tstate);
43876 if (PyErr_Occurred()) SWIG_fail;
43877 }
43878 resultobj = SWIG_Py_Void();
43879 return resultobj;
43880 fail:
43881 return NULL;
43882 }
43883
43884
43885 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43886 PyObject *resultobj = 0;
43887 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43888 int arg2 ;
43889 PyObject *result = 0 ;
43890 void *argp1 = 0 ;
43891 int res1 = 0 ;
43892 int val2 ;
43893 int ecode2 = 0 ;
43894 PyObject * obj0 = 0 ;
43895 PyObject * obj1 = 0 ;
43896 char * kwnames[] = {
43897 (char *) "self",(char *) "n", NULL
43898 };
43899
43900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
43901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43902 if (!SWIG_IsOK(res1)) {
43903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43904 }
43905 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43906 ecode2 = SWIG_AsVal_int(obj1, &val2);
43907 if (!SWIG_IsOK(ecode2)) {
43908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
43909 }
43910 arg2 = static_cast< int >(val2);
43911 {
43912 PyThreadState* __tstate = wxPyBeginAllowThreads();
43913 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
43914 wxPyEndAllowThreads(__tstate);
43915 if (PyErr_Occurred()) SWIG_fail;
43916 }
43917 resultobj = result;
43918 return resultobj;
43919 fail:
43920 return NULL;
43921 }
43922
43923
43924 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43925 PyObject *resultobj = 0;
43926 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43927 int arg2 ;
43928 PyObject *arg3 = (PyObject *) 0 ;
43929 void *argp1 = 0 ;
43930 int res1 = 0 ;
43931 int val2 ;
43932 int ecode2 = 0 ;
43933 PyObject * obj0 = 0 ;
43934 PyObject * obj1 = 0 ;
43935 PyObject * obj2 = 0 ;
43936 char * kwnames[] = {
43937 (char *) "self",(char *) "n",(char *) "clientData", NULL
43938 };
43939
43940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43942 if (!SWIG_IsOK(res1)) {
43943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43944 }
43945 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43946 ecode2 = SWIG_AsVal_int(obj1, &val2);
43947 if (!SWIG_IsOK(ecode2)) {
43948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
43949 }
43950 arg2 = static_cast< int >(val2);
43951 arg3 = obj2;
43952 {
43953 PyThreadState* __tstate = wxPyBeginAllowThreads();
43954 wxItemContainer_SetClientData(arg1,arg2,arg3);
43955 wxPyEndAllowThreads(__tstate);
43956 if (PyErr_Occurred()) SWIG_fail;
43957 }
43958 resultobj = SWIG_Py_Void();
43959 return resultobj;
43960 fail:
43961 return NULL;
43962 }
43963
43964
43965 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43966 PyObject *resultobj = 0;
43967 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43968 int result;
43969 void *argp1 = 0 ;
43970 int res1 = 0 ;
43971 PyObject *swig_obj[1] ;
43972
43973 if (!args) SWIG_fail;
43974 swig_obj[0] = args;
43975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43976 if (!SWIG_IsOK(res1)) {
43977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
43978 }
43979 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43980 {
43981 PyThreadState* __tstate = wxPyBeginAllowThreads();
43982 result = (int)((wxItemContainer const *)arg1)->GetCount();
43983 wxPyEndAllowThreads(__tstate);
43984 if (PyErr_Occurred()) SWIG_fail;
43985 }
43986 resultobj = SWIG_From_int(static_cast< int >(result));
43987 return resultobj;
43988 fail:
43989 return NULL;
43990 }
43991
43992
43993 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43994 PyObject *resultobj = 0;
43995 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43996 bool result;
43997 void *argp1 = 0 ;
43998 int res1 = 0 ;
43999 PyObject *swig_obj[1] ;
44000
44001 if (!args) SWIG_fail;
44002 swig_obj[0] = args;
44003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44004 if (!SWIG_IsOK(res1)) {
44005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44006 }
44007 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44008 {
44009 PyThreadState* __tstate = wxPyBeginAllowThreads();
44010 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44011 wxPyEndAllowThreads(__tstate);
44012 if (PyErr_Occurred()) SWIG_fail;
44013 }
44014 {
44015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44016 }
44017 return resultobj;
44018 fail:
44019 return NULL;
44020 }
44021
44022
44023 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44024 PyObject *resultobj = 0;
44025 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44026 int arg2 ;
44027 wxString result;
44028 void *argp1 = 0 ;
44029 int res1 = 0 ;
44030 int val2 ;
44031 int ecode2 = 0 ;
44032 PyObject * obj0 = 0 ;
44033 PyObject * obj1 = 0 ;
44034 char * kwnames[] = {
44035 (char *) "self",(char *) "n", NULL
44036 };
44037
44038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44040 if (!SWIG_IsOK(res1)) {
44041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44042 }
44043 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44044 ecode2 = SWIG_AsVal_int(obj1, &val2);
44045 if (!SWIG_IsOK(ecode2)) {
44046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
44047 }
44048 arg2 = static_cast< int >(val2);
44049 {
44050 PyThreadState* __tstate = wxPyBeginAllowThreads();
44051 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44052 wxPyEndAllowThreads(__tstate);
44053 if (PyErr_Occurred()) SWIG_fail;
44054 }
44055 {
44056 #if wxUSE_UNICODE
44057 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44058 #else
44059 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44060 #endif
44061 }
44062 return resultobj;
44063 fail:
44064 return NULL;
44065 }
44066
44067
44068 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44069 PyObject *resultobj = 0;
44070 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44071 wxArrayString result;
44072 void *argp1 = 0 ;
44073 int res1 = 0 ;
44074 PyObject *swig_obj[1] ;
44075
44076 if (!args) SWIG_fail;
44077 swig_obj[0] = args;
44078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44079 if (!SWIG_IsOK(res1)) {
44080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44081 }
44082 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44083 {
44084 PyThreadState* __tstate = wxPyBeginAllowThreads();
44085 result = ((wxItemContainer const *)arg1)->GetStrings();
44086 wxPyEndAllowThreads(__tstate);
44087 if (PyErr_Occurred()) SWIG_fail;
44088 }
44089 {
44090 resultobj = wxArrayString2PyList_helper(result);
44091 }
44092 return resultobj;
44093 fail:
44094 return NULL;
44095 }
44096
44097
44098 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44099 PyObject *resultobj = 0;
44100 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44101 int arg2 ;
44102 wxString *arg3 = 0 ;
44103 void *argp1 = 0 ;
44104 int res1 = 0 ;
44105 int val2 ;
44106 int ecode2 = 0 ;
44107 bool temp3 = false ;
44108 PyObject * obj0 = 0 ;
44109 PyObject * obj1 = 0 ;
44110 PyObject * obj2 = 0 ;
44111 char * kwnames[] = {
44112 (char *) "self",(char *) "n",(char *) "s", NULL
44113 };
44114
44115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44117 if (!SWIG_IsOK(res1)) {
44118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44119 }
44120 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44121 ecode2 = SWIG_AsVal_int(obj1, &val2);
44122 if (!SWIG_IsOK(ecode2)) {
44123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
44124 }
44125 arg2 = static_cast< int >(val2);
44126 {
44127 arg3 = wxString_in_helper(obj2);
44128 if (arg3 == NULL) SWIG_fail;
44129 temp3 = true;
44130 }
44131 {
44132 PyThreadState* __tstate = wxPyBeginAllowThreads();
44133 (arg1)->SetString(arg2,(wxString const &)*arg3);
44134 wxPyEndAllowThreads(__tstate);
44135 if (PyErr_Occurred()) SWIG_fail;
44136 }
44137 resultobj = SWIG_Py_Void();
44138 {
44139 if (temp3)
44140 delete arg3;
44141 }
44142 return resultobj;
44143 fail:
44144 {
44145 if (temp3)
44146 delete arg3;
44147 }
44148 return NULL;
44149 }
44150
44151
44152 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44153 PyObject *resultobj = 0;
44154 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44155 wxString *arg2 = 0 ;
44156 int result;
44157 void *argp1 = 0 ;
44158 int res1 = 0 ;
44159 bool temp2 = false ;
44160 PyObject * obj0 = 0 ;
44161 PyObject * obj1 = 0 ;
44162 char * kwnames[] = {
44163 (char *) "self",(char *) "s", NULL
44164 };
44165
44166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44168 if (!SWIG_IsOK(res1)) {
44169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44170 }
44171 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44172 {
44173 arg2 = wxString_in_helper(obj1);
44174 if (arg2 == NULL) SWIG_fail;
44175 temp2 = true;
44176 }
44177 {
44178 PyThreadState* __tstate = wxPyBeginAllowThreads();
44179 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44180 wxPyEndAllowThreads(__tstate);
44181 if (PyErr_Occurred()) SWIG_fail;
44182 }
44183 resultobj = SWIG_From_int(static_cast< int >(result));
44184 {
44185 if (temp2)
44186 delete arg2;
44187 }
44188 return resultobj;
44189 fail:
44190 {
44191 if (temp2)
44192 delete arg2;
44193 }
44194 return NULL;
44195 }
44196
44197
44198 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44199 PyObject *resultobj = 0;
44200 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44201 int arg2 ;
44202 void *argp1 = 0 ;
44203 int res1 = 0 ;
44204 int val2 ;
44205 int ecode2 = 0 ;
44206 PyObject * obj0 = 0 ;
44207 PyObject * obj1 = 0 ;
44208 char * kwnames[] = {
44209 (char *) "self",(char *) "n", NULL
44210 };
44211
44212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44214 if (!SWIG_IsOK(res1)) {
44215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44216 }
44217 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44218 ecode2 = SWIG_AsVal_int(obj1, &val2);
44219 if (!SWIG_IsOK(ecode2)) {
44220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44221 }
44222 arg2 = static_cast< int >(val2);
44223 {
44224 PyThreadState* __tstate = wxPyBeginAllowThreads();
44225 (arg1)->SetSelection(arg2);
44226 wxPyEndAllowThreads(__tstate);
44227 if (PyErr_Occurred()) SWIG_fail;
44228 }
44229 resultobj = SWIG_Py_Void();
44230 return resultobj;
44231 fail:
44232 return NULL;
44233 }
44234
44235
44236 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44237 PyObject *resultobj = 0;
44238 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44239 int result;
44240 void *argp1 = 0 ;
44241 int res1 = 0 ;
44242 PyObject *swig_obj[1] ;
44243
44244 if (!args) SWIG_fail;
44245 swig_obj[0] = args;
44246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44247 if (!SWIG_IsOK(res1)) {
44248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44249 }
44250 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44251 {
44252 PyThreadState* __tstate = wxPyBeginAllowThreads();
44253 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44254 wxPyEndAllowThreads(__tstate);
44255 if (PyErr_Occurred()) SWIG_fail;
44256 }
44257 resultobj = SWIG_From_int(static_cast< int >(result));
44258 return resultobj;
44259 fail:
44260 return NULL;
44261 }
44262
44263
44264 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44265 PyObject *resultobj = 0;
44266 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44267 wxString *arg2 = 0 ;
44268 bool result;
44269 void *argp1 = 0 ;
44270 int res1 = 0 ;
44271 bool temp2 = false ;
44272 PyObject * obj0 = 0 ;
44273 PyObject * obj1 = 0 ;
44274 char * kwnames[] = {
44275 (char *) "self",(char *) "s", NULL
44276 };
44277
44278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44280 if (!SWIG_IsOK(res1)) {
44281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44282 }
44283 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44284 {
44285 arg2 = wxString_in_helper(obj1);
44286 if (arg2 == NULL) SWIG_fail;
44287 temp2 = true;
44288 }
44289 {
44290 PyThreadState* __tstate = wxPyBeginAllowThreads();
44291 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44292 wxPyEndAllowThreads(__tstate);
44293 if (PyErr_Occurred()) SWIG_fail;
44294 }
44295 {
44296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44297 }
44298 {
44299 if (temp2)
44300 delete arg2;
44301 }
44302 return resultobj;
44303 fail:
44304 {
44305 if (temp2)
44306 delete arg2;
44307 }
44308 return NULL;
44309 }
44310
44311
44312 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44313 PyObject *resultobj = 0;
44314 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44315 wxString result;
44316 void *argp1 = 0 ;
44317 int res1 = 0 ;
44318 PyObject *swig_obj[1] ;
44319
44320 if (!args) SWIG_fail;
44321 swig_obj[0] = args;
44322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44323 if (!SWIG_IsOK(res1)) {
44324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44325 }
44326 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44327 {
44328 PyThreadState* __tstate = wxPyBeginAllowThreads();
44329 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44330 wxPyEndAllowThreads(__tstate);
44331 if (PyErr_Occurred()) SWIG_fail;
44332 }
44333 {
44334 #if wxUSE_UNICODE
44335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44336 #else
44337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44338 #endif
44339 }
44340 return resultobj;
44341 fail:
44342 return NULL;
44343 }
44344
44345
44346 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44347 PyObject *resultobj = 0;
44348 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44349 int arg2 ;
44350 void *argp1 = 0 ;
44351 int res1 = 0 ;
44352 int val2 ;
44353 int ecode2 = 0 ;
44354 PyObject * obj0 = 0 ;
44355 PyObject * obj1 = 0 ;
44356 char * kwnames[] = {
44357 (char *) "self",(char *) "n", NULL
44358 };
44359
44360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44362 if (!SWIG_IsOK(res1)) {
44363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44364 }
44365 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44366 ecode2 = SWIG_AsVal_int(obj1, &val2);
44367 if (!SWIG_IsOK(ecode2)) {
44368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44369 }
44370 arg2 = static_cast< int >(val2);
44371 {
44372 PyThreadState* __tstate = wxPyBeginAllowThreads();
44373 (arg1)->Select(arg2);
44374 wxPyEndAllowThreads(__tstate);
44375 if (PyErr_Occurred()) SWIG_fail;
44376 }
44377 resultobj = SWIG_Py_Void();
44378 return resultobj;
44379 fail:
44380 return NULL;
44381 }
44382
44383
44384 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44385 PyObject *obj;
44386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44387 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44388 return SWIG_Py_Void();
44389 }
44390
44391 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44392 PyObject *obj;
44393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44394 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44395 return SWIG_Py_Void();
44396 }
44397
44398 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44399 PyObject *resultobj = 0;
44400 wxSizerItem *result = 0 ;
44401
44402 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44403 {
44404 PyThreadState* __tstate = wxPyBeginAllowThreads();
44405 result = (wxSizerItem *)new wxSizerItem();
44406 wxPyEndAllowThreads(__tstate);
44407 if (PyErr_Occurred()) SWIG_fail;
44408 }
44409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44410 return resultobj;
44411 fail:
44412 return NULL;
44413 }
44414
44415
44416 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44417 PyObject *resultobj = 0;
44418 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44419 void *argp1 = 0 ;
44420 int res1 = 0 ;
44421 PyObject *swig_obj[1] ;
44422
44423 if (!args) SWIG_fail;
44424 swig_obj[0] = args;
44425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44426 if (!SWIG_IsOK(res1)) {
44427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44428 }
44429 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44430 {
44431 PyThreadState* __tstate = wxPyBeginAllowThreads();
44432 delete arg1;
44433
44434 wxPyEndAllowThreads(__tstate);
44435 if (PyErr_Occurred()) SWIG_fail;
44436 }
44437 resultobj = SWIG_Py_Void();
44438 return resultobj;
44439 fail:
44440 return NULL;
44441 }
44442
44443
44444 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44445 PyObject *resultobj = 0;
44446 wxWindow *arg1 = (wxWindow *) 0 ;
44447 int arg2 ;
44448 int arg3 ;
44449 int arg4 ;
44450 PyObject *arg5 = (PyObject *) NULL ;
44451 wxSizerItem *result = 0 ;
44452 void *argp1 = 0 ;
44453 int res1 = 0 ;
44454 int val2 ;
44455 int ecode2 = 0 ;
44456 int val3 ;
44457 int ecode3 = 0 ;
44458 int val4 ;
44459 int ecode4 = 0 ;
44460 PyObject * obj0 = 0 ;
44461 PyObject * obj1 = 0 ;
44462 PyObject * obj2 = 0 ;
44463 PyObject * obj3 = 0 ;
44464 PyObject * obj4 = 0 ;
44465 char * kwnames[] = {
44466 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44467 };
44468
44469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44471 if (!SWIG_IsOK(res1)) {
44472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44473 }
44474 arg1 = reinterpret_cast< wxWindow * >(argp1);
44475 ecode2 = SWIG_AsVal_int(obj1, &val2);
44476 if (!SWIG_IsOK(ecode2)) {
44477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44478 }
44479 arg2 = static_cast< int >(val2);
44480 ecode3 = SWIG_AsVal_int(obj2, &val3);
44481 if (!SWIG_IsOK(ecode3)) {
44482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44483 }
44484 arg3 = static_cast< int >(val3);
44485 ecode4 = SWIG_AsVal_int(obj3, &val4);
44486 if (!SWIG_IsOK(ecode4)) {
44487 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44488 }
44489 arg4 = static_cast< int >(val4);
44490 if (obj4) {
44491 arg5 = obj4;
44492 }
44493 {
44494 PyThreadState* __tstate = wxPyBeginAllowThreads();
44495 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44496 wxPyEndAllowThreads(__tstate);
44497 if (PyErr_Occurred()) SWIG_fail;
44498 }
44499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44500 return resultobj;
44501 fail:
44502 return NULL;
44503 }
44504
44505
44506 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44507 PyObject *resultobj = 0;
44508 int arg1 ;
44509 int arg2 ;
44510 int arg3 ;
44511 int arg4 ;
44512 int arg5 ;
44513 PyObject *arg6 = (PyObject *) NULL ;
44514 wxSizerItem *result = 0 ;
44515 int val1 ;
44516 int ecode1 = 0 ;
44517 int val2 ;
44518 int ecode2 = 0 ;
44519 int val3 ;
44520 int ecode3 = 0 ;
44521 int val4 ;
44522 int ecode4 = 0 ;
44523 int val5 ;
44524 int ecode5 = 0 ;
44525 PyObject * obj0 = 0 ;
44526 PyObject * obj1 = 0 ;
44527 PyObject * obj2 = 0 ;
44528 PyObject * obj3 = 0 ;
44529 PyObject * obj4 = 0 ;
44530 PyObject * obj5 = 0 ;
44531 char * kwnames[] = {
44532 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44533 };
44534
44535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44536 ecode1 = SWIG_AsVal_int(obj0, &val1);
44537 if (!SWIG_IsOK(ecode1)) {
44538 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44539 }
44540 arg1 = static_cast< int >(val1);
44541 ecode2 = SWIG_AsVal_int(obj1, &val2);
44542 if (!SWIG_IsOK(ecode2)) {
44543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44544 }
44545 arg2 = static_cast< int >(val2);
44546 ecode3 = SWIG_AsVal_int(obj2, &val3);
44547 if (!SWIG_IsOK(ecode3)) {
44548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44549 }
44550 arg3 = static_cast< int >(val3);
44551 ecode4 = SWIG_AsVal_int(obj3, &val4);
44552 if (!SWIG_IsOK(ecode4)) {
44553 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44554 }
44555 arg4 = static_cast< int >(val4);
44556 ecode5 = SWIG_AsVal_int(obj4, &val5);
44557 if (!SWIG_IsOK(ecode5)) {
44558 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44559 }
44560 arg5 = static_cast< int >(val5);
44561 if (obj5) {
44562 arg6 = obj5;
44563 }
44564 {
44565 PyThreadState* __tstate = wxPyBeginAllowThreads();
44566 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44567 wxPyEndAllowThreads(__tstate);
44568 if (PyErr_Occurred()) SWIG_fail;
44569 }
44570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44571 return resultobj;
44572 fail:
44573 return NULL;
44574 }
44575
44576
44577 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44578 PyObject *resultobj = 0;
44579 wxSizer *arg1 = (wxSizer *) 0 ;
44580 int arg2 ;
44581 int arg3 ;
44582 int arg4 ;
44583 PyObject *arg5 = (PyObject *) NULL ;
44584 wxSizerItem *result = 0 ;
44585 int res1 = 0 ;
44586 int val2 ;
44587 int ecode2 = 0 ;
44588 int val3 ;
44589 int ecode3 = 0 ;
44590 int val4 ;
44591 int ecode4 = 0 ;
44592 PyObject * obj0 = 0 ;
44593 PyObject * obj1 = 0 ;
44594 PyObject * obj2 = 0 ;
44595 PyObject * obj3 = 0 ;
44596 PyObject * obj4 = 0 ;
44597 char * kwnames[] = {
44598 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44599 };
44600
44601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44602 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44603 if (!SWIG_IsOK(res1)) {
44604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44605 }
44606 ecode2 = SWIG_AsVal_int(obj1, &val2);
44607 if (!SWIG_IsOK(ecode2)) {
44608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44609 }
44610 arg2 = static_cast< int >(val2);
44611 ecode3 = SWIG_AsVal_int(obj2, &val3);
44612 if (!SWIG_IsOK(ecode3)) {
44613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44614 }
44615 arg3 = static_cast< int >(val3);
44616 ecode4 = SWIG_AsVal_int(obj3, &val4);
44617 if (!SWIG_IsOK(ecode4)) {
44618 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44619 }
44620 arg4 = static_cast< int >(val4);
44621 if (obj4) {
44622 arg5 = obj4;
44623 }
44624 {
44625 PyThreadState* __tstate = wxPyBeginAllowThreads();
44626 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44627 wxPyEndAllowThreads(__tstate);
44628 if (PyErr_Occurred()) SWIG_fail;
44629 }
44630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44631 return resultobj;
44632 fail:
44633 return NULL;
44634 }
44635
44636
44637 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44638 PyObject *resultobj = 0;
44639 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44640 void *argp1 = 0 ;
44641 int res1 = 0 ;
44642 PyObject *swig_obj[1] ;
44643
44644 if (!args) SWIG_fail;
44645 swig_obj[0] = args;
44646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44647 if (!SWIG_IsOK(res1)) {
44648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44649 }
44650 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44651 {
44652 PyThreadState* __tstate = wxPyBeginAllowThreads();
44653 (arg1)->DeleteWindows();
44654 wxPyEndAllowThreads(__tstate);
44655 if (PyErr_Occurred()) SWIG_fail;
44656 }
44657 resultobj = SWIG_Py_Void();
44658 return resultobj;
44659 fail:
44660 return NULL;
44661 }
44662
44663
44664 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44665 PyObject *resultobj = 0;
44666 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44667 void *argp1 = 0 ;
44668 int res1 = 0 ;
44669 PyObject *swig_obj[1] ;
44670
44671 if (!args) SWIG_fail;
44672 swig_obj[0] = args;
44673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44674 if (!SWIG_IsOK(res1)) {
44675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44676 }
44677 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44678 {
44679 PyThreadState* __tstate = wxPyBeginAllowThreads();
44680 (arg1)->DetachSizer();
44681 wxPyEndAllowThreads(__tstate);
44682 if (PyErr_Occurred()) SWIG_fail;
44683 }
44684 resultobj = SWIG_Py_Void();
44685 return resultobj;
44686 fail:
44687 return NULL;
44688 }
44689
44690
44691 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44692 PyObject *resultobj = 0;
44693 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44694 wxSize result;
44695 void *argp1 = 0 ;
44696 int res1 = 0 ;
44697 PyObject *swig_obj[1] ;
44698
44699 if (!args) SWIG_fail;
44700 swig_obj[0] = args;
44701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44702 if (!SWIG_IsOK(res1)) {
44703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44704 }
44705 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44706 {
44707 PyThreadState* __tstate = wxPyBeginAllowThreads();
44708 result = (arg1)->GetSize();
44709 wxPyEndAllowThreads(__tstate);
44710 if (PyErr_Occurred()) SWIG_fail;
44711 }
44712 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44713 return resultobj;
44714 fail:
44715 return NULL;
44716 }
44717
44718
44719 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44720 PyObject *resultobj = 0;
44721 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44722 wxSize result;
44723 void *argp1 = 0 ;
44724 int res1 = 0 ;
44725 PyObject *swig_obj[1] ;
44726
44727 if (!args) SWIG_fail;
44728 swig_obj[0] = args;
44729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44730 if (!SWIG_IsOK(res1)) {
44731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44732 }
44733 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44734 {
44735 PyThreadState* __tstate = wxPyBeginAllowThreads();
44736 result = (arg1)->CalcMin();
44737 wxPyEndAllowThreads(__tstate);
44738 if (PyErr_Occurred()) SWIG_fail;
44739 }
44740 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44741 return resultobj;
44742 fail:
44743 return NULL;
44744 }
44745
44746
44747 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44748 PyObject *resultobj = 0;
44749 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44750 wxPoint *arg2 = 0 ;
44751 wxSize *arg3 = 0 ;
44752 void *argp1 = 0 ;
44753 int res1 = 0 ;
44754 wxPoint temp2 ;
44755 wxSize temp3 ;
44756 PyObject * obj0 = 0 ;
44757 PyObject * obj1 = 0 ;
44758 PyObject * obj2 = 0 ;
44759 char * kwnames[] = {
44760 (char *) "self",(char *) "pos",(char *) "size", NULL
44761 };
44762
44763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44765 if (!SWIG_IsOK(res1)) {
44766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44767 }
44768 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44769 {
44770 arg2 = &temp2;
44771 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44772 }
44773 {
44774 arg3 = &temp3;
44775 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
44776 }
44777 {
44778 PyThreadState* __tstate = wxPyBeginAllowThreads();
44779 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
44780 wxPyEndAllowThreads(__tstate);
44781 if (PyErr_Occurred()) SWIG_fail;
44782 }
44783 resultobj = SWIG_Py_Void();
44784 return resultobj;
44785 fail:
44786 return NULL;
44787 }
44788
44789
44790 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44791 PyObject *resultobj = 0;
44792 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44793 wxSize result;
44794 void *argp1 = 0 ;
44795 int res1 = 0 ;
44796 PyObject *swig_obj[1] ;
44797
44798 if (!args) SWIG_fail;
44799 swig_obj[0] = args;
44800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44801 if (!SWIG_IsOK(res1)) {
44802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44803 }
44804 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44805 {
44806 PyThreadState* __tstate = wxPyBeginAllowThreads();
44807 result = (arg1)->GetMinSize();
44808 wxPyEndAllowThreads(__tstate);
44809 if (PyErr_Occurred()) SWIG_fail;
44810 }
44811 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44812 return resultobj;
44813 fail:
44814 return NULL;
44815 }
44816
44817
44818 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44819 PyObject *resultobj = 0;
44820 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44821 wxSize result;
44822 void *argp1 = 0 ;
44823 int res1 = 0 ;
44824 PyObject *swig_obj[1] ;
44825
44826 if (!args) SWIG_fail;
44827 swig_obj[0] = args;
44828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44829 if (!SWIG_IsOK(res1)) {
44830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
44831 }
44832 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44833 {
44834 PyThreadState* __tstate = wxPyBeginAllowThreads();
44835 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
44836 wxPyEndAllowThreads(__tstate);
44837 if (PyErr_Occurred()) SWIG_fail;
44838 }
44839 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44840 return resultobj;
44841 fail:
44842 return NULL;
44843 }
44844
44845
44846 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44847 PyObject *resultobj = 0;
44848 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44849 int arg2 ;
44850 int arg3 ;
44851 void *argp1 = 0 ;
44852 int res1 = 0 ;
44853 int val2 ;
44854 int ecode2 = 0 ;
44855 int val3 ;
44856 int ecode3 = 0 ;
44857 PyObject * obj0 = 0 ;
44858 PyObject * obj1 = 0 ;
44859 PyObject * obj2 = 0 ;
44860 char * kwnames[] = {
44861 (char *) "self",(char *) "x",(char *) "y", NULL
44862 };
44863
44864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44866 if (!SWIG_IsOK(res1)) {
44867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44868 }
44869 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44870 ecode2 = SWIG_AsVal_int(obj1, &val2);
44871 if (!SWIG_IsOK(ecode2)) {
44872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
44873 }
44874 arg2 = static_cast< int >(val2);
44875 ecode3 = SWIG_AsVal_int(obj2, &val3);
44876 if (!SWIG_IsOK(ecode3)) {
44877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
44878 }
44879 arg3 = static_cast< int >(val3);
44880 {
44881 PyThreadState* __tstate = wxPyBeginAllowThreads();
44882 (arg1)->SetInitSize(arg2,arg3);
44883 wxPyEndAllowThreads(__tstate);
44884 if (PyErr_Occurred()) SWIG_fail;
44885 }
44886 resultobj = SWIG_Py_Void();
44887 return resultobj;
44888 fail:
44889 return NULL;
44890 }
44891
44892
44893 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44894 PyObject *resultobj = 0;
44895 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44896 int arg2 ;
44897 int arg3 ;
44898 void *argp1 = 0 ;
44899 int res1 = 0 ;
44900 int val2 ;
44901 int ecode2 = 0 ;
44902 int val3 ;
44903 int ecode3 = 0 ;
44904 PyObject * obj0 = 0 ;
44905 PyObject * obj1 = 0 ;
44906 PyObject * obj2 = 0 ;
44907 char * kwnames[] = {
44908 (char *) "self",(char *) "width",(char *) "height", NULL
44909 };
44910
44911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44913 if (!SWIG_IsOK(res1)) {
44914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44915 }
44916 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44917 ecode2 = SWIG_AsVal_int(obj1, &val2);
44918 if (!SWIG_IsOK(ecode2)) {
44919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
44920 }
44921 arg2 = static_cast< int >(val2);
44922 ecode3 = SWIG_AsVal_int(obj2, &val3);
44923 if (!SWIG_IsOK(ecode3)) {
44924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
44925 }
44926 arg3 = static_cast< int >(val3);
44927 {
44928 PyThreadState* __tstate = wxPyBeginAllowThreads();
44929 (arg1)->SetRatio(arg2,arg3);
44930 wxPyEndAllowThreads(__tstate);
44931 if (PyErr_Occurred()) SWIG_fail;
44932 }
44933 resultobj = SWIG_Py_Void();
44934 return resultobj;
44935 fail:
44936 return NULL;
44937 }
44938
44939
44940 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44941 PyObject *resultobj = 0;
44942 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44943 wxSize *arg2 = 0 ;
44944 void *argp1 = 0 ;
44945 int res1 = 0 ;
44946 wxSize temp2 ;
44947 PyObject * obj0 = 0 ;
44948 PyObject * obj1 = 0 ;
44949 char * kwnames[] = {
44950 (char *) "self",(char *) "size", NULL
44951 };
44952
44953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
44954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44955 if (!SWIG_IsOK(res1)) {
44956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44957 }
44958 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44959 {
44960 arg2 = &temp2;
44961 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
44962 }
44963 {
44964 PyThreadState* __tstate = wxPyBeginAllowThreads();
44965 (arg1)->SetRatio((wxSize const &)*arg2);
44966 wxPyEndAllowThreads(__tstate);
44967 if (PyErr_Occurred()) SWIG_fail;
44968 }
44969 resultobj = SWIG_Py_Void();
44970 return resultobj;
44971 fail:
44972 return NULL;
44973 }
44974
44975
44976 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44977 PyObject *resultobj = 0;
44978 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44979 float arg2 ;
44980 void *argp1 = 0 ;
44981 int res1 = 0 ;
44982 float val2 ;
44983 int ecode2 = 0 ;
44984 PyObject * obj0 = 0 ;
44985 PyObject * obj1 = 0 ;
44986 char * kwnames[] = {
44987 (char *) "self",(char *) "ratio", NULL
44988 };
44989
44990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
44991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44992 if (!SWIG_IsOK(res1)) {
44993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44994 }
44995 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44996 ecode2 = SWIG_AsVal_float(obj1, &val2);
44997 if (!SWIG_IsOK(ecode2)) {
44998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
44999 }
45000 arg2 = static_cast< float >(val2);
45001 {
45002 PyThreadState* __tstate = wxPyBeginAllowThreads();
45003 (arg1)->SetRatio(arg2);
45004 wxPyEndAllowThreads(__tstate);
45005 if (PyErr_Occurred()) SWIG_fail;
45006 }
45007 resultobj = SWIG_Py_Void();
45008 return resultobj;
45009 fail:
45010 return NULL;
45011 }
45012
45013
45014 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45015 PyObject *resultobj = 0;
45016 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45017 float result;
45018 void *argp1 = 0 ;
45019 int res1 = 0 ;
45020 PyObject *swig_obj[1] ;
45021
45022 if (!args) SWIG_fail;
45023 swig_obj[0] = args;
45024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45025 if (!SWIG_IsOK(res1)) {
45026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45027 }
45028 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45029 {
45030 PyThreadState* __tstate = wxPyBeginAllowThreads();
45031 result = (float)(arg1)->GetRatio();
45032 wxPyEndAllowThreads(__tstate);
45033 if (PyErr_Occurred()) SWIG_fail;
45034 }
45035 resultobj = SWIG_From_float(static_cast< float >(result));
45036 return resultobj;
45037 fail:
45038 return NULL;
45039 }
45040
45041
45042 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45043 PyObject *resultobj = 0;
45044 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45045 wxRect result;
45046 void *argp1 = 0 ;
45047 int res1 = 0 ;
45048 PyObject *swig_obj[1] ;
45049
45050 if (!args) SWIG_fail;
45051 swig_obj[0] = args;
45052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45053 if (!SWIG_IsOK(res1)) {
45054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45055 }
45056 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45057 {
45058 PyThreadState* __tstate = wxPyBeginAllowThreads();
45059 result = (arg1)->GetRect();
45060 wxPyEndAllowThreads(__tstate);
45061 if (PyErr_Occurred()) SWIG_fail;
45062 }
45063 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45064 return resultobj;
45065 fail:
45066 return NULL;
45067 }
45068
45069
45070 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45071 PyObject *resultobj = 0;
45072 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45073 bool result;
45074 void *argp1 = 0 ;
45075 int res1 = 0 ;
45076 PyObject *swig_obj[1] ;
45077
45078 if (!args) SWIG_fail;
45079 swig_obj[0] = args;
45080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45081 if (!SWIG_IsOK(res1)) {
45082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45083 }
45084 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45085 {
45086 PyThreadState* __tstate = wxPyBeginAllowThreads();
45087 result = (bool)(arg1)->IsWindow();
45088 wxPyEndAllowThreads(__tstate);
45089 if (PyErr_Occurred()) SWIG_fail;
45090 }
45091 {
45092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45093 }
45094 return resultobj;
45095 fail:
45096 return NULL;
45097 }
45098
45099
45100 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45101 PyObject *resultobj = 0;
45102 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45103 bool result;
45104 void *argp1 = 0 ;
45105 int res1 = 0 ;
45106 PyObject *swig_obj[1] ;
45107
45108 if (!args) SWIG_fail;
45109 swig_obj[0] = args;
45110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45111 if (!SWIG_IsOK(res1)) {
45112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45113 }
45114 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45115 {
45116 PyThreadState* __tstate = wxPyBeginAllowThreads();
45117 result = (bool)(arg1)->IsSizer();
45118 wxPyEndAllowThreads(__tstate);
45119 if (PyErr_Occurred()) SWIG_fail;
45120 }
45121 {
45122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45123 }
45124 return resultobj;
45125 fail:
45126 return NULL;
45127 }
45128
45129
45130 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45131 PyObject *resultobj = 0;
45132 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45133 bool result;
45134 void *argp1 = 0 ;
45135 int res1 = 0 ;
45136 PyObject *swig_obj[1] ;
45137
45138 if (!args) SWIG_fail;
45139 swig_obj[0] = args;
45140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45141 if (!SWIG_IsOK(res1)) {
45142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45143 }
45144 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45145 {
45146 PyThreadState* __tstate = wxPyBeginAllowThreads();
45147 result = (bool)(arg1)->IsSpacer();
45148 wxPyEndAllowThreads(__tstate);
45149 if (PyErr_Occurred()) SWIG_fail;
45150 }
45151 {
45152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45153 }
45154 return resultobj;
45155 fail:
45156 return NULL;
45157 }
45158
45159
45160 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45161 PyObject *resultobj = 0;
45162 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45163 int arg2 ;
45164 void *argp1 = 0 ;
45165 int res1 = 0 ;
45166 int val2 ;
45167 int ecode2 = 0 ;
45168 PyObject * obj0 = 0 ;
45169 PyObject * obj1 = 0 ;
45170 char * kwnames[] = {
45171 (char *) "self",(char *) "proportion", NULL
45172 };
45173
45174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45176 if (!SWIG_IsOK(res1)) {
45177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45178 }
45179 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45180 ecode2 = SWIG_AsVal_int(obj1, &val2);
45181 if (!SWIG_IsOK(ecode2)) {
45182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45183 }
45184 arg2 = static_cast< int >(val2);
45185 {
45186 PyThreadState* __tstate = wxPyBeginAllowThreads();
45187 (arg1)->SetProportion(arg2);
45188 wxPyEndAllowThreads(__tstate);
45189 if (PyErr_Occurred()) SWIG_fail;
45190 }
45191 resultobj = SWIG_Py_Void();
45192 return resultobj;
45193 fail:
45194 return NULL;
45195 }
45196
45197
45198 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45199 PyObject *resultobj = 0;
45200 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45201 int result;
45202 void *argp1 = 0 ;
45203 int res1 = 0 ;
45204 PyObject *swig_obj[1] ;
45205
45206 if (!args) SWIG_fail;
45207 swig_obj[0] = args;
45208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45209 if (!SWIG_IsOK(res1)) {
45210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45211 }
45212 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45213 {
45214 PyThreadState* __tstate = wxPyBeginAllowThreads();
45215 result = (int)(arg1)->GetProportion();
45216 wxPyEndAllowThreads(__tstate);
45217 if (PyErr_Occurred()) SWIG_fail;
45218 }
45219 resultobj = SWIG_From_int(static_cast< int >(result));
45220 return resultobj;
45221 fail:
45222 return NULL;
45223 }
45224
45225
45226 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45227 PyObject *resultobj = 0;
45228 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45229 int arg2 ;
45230 void *argp1 = 0 ;
45231 int res1 = 0 ;
45232 int val2 ;
45233 int ecode2 = 0 ;
45234 PyObject * obj0 = 0 ;
45235 PyObject * obj1 = 0 ;
45236 char * kwnames[] = {
45237 (char *) "self",(char *) "flag", NULL
45238 };
45239
45240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45242 if (!SWIG_IsOK(res1)) {
45243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45244 }
45245 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45246 ecode2 = SWIG_AsVal_int(obj1, &val2);
45247 if (!SWIG_IsOK(ecode2)) {
45248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45249 }
45250 arg2 = static_cast< int >(val2);
45251 {
45252 PyThreadState* __tstate = wxPyBeginAllowThreads();
45253 (arg1)->SetFlag(arg2);
45254 wxPyEndAllowThreads(__tstate);
45255 if (PyErr_Occurred()) SWIG_fail;
45256 }
45257 resultobj = SWIG_Py_Void();
45258 return resultobj;
45259 fail:
45260 return NULL;
45261 }
45262
45263
45264 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45265 PyObject *resultobj = 0;
45266 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45267 int result;
45268 void *argp1 = 0 ;
45269 int res1 = 0 ;
45270 PyObject *swig_obj[1] ;
45271
45272 if (!args) SWIG_fail;
45273 swig_obj[0] = args;
45274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45275 if (!SWIG_IsOK(res1)) {
45276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45277 }
45278 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45279 {
45280 PyThreadState* __tstate = wxPyBeginAllowThreads();
45281 result = (int)(arg1)->GetFlag();
45282 wxPyEndAllowThreads(__tstate);
45283 if (PyErr_Occurred()) SWIG_fail;
45284 }
45285 resultobj = SWIG_From_int(static_cast< int >(result));
45286 return resultobj;
45287 fail:
45288 return NULL;
45289 }
45290
45291
45292 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45293 PyObject *resultobj = 0;
45294 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45295 int arg2 ;
45296 void *argp1 = 0 ;
45297 int res1 = 0 ;
45298 int val2 ;
45299 int ecode2 = 0 ;
45300 PyObject * obj0 = 0 ;
45301 PyObject * obj1 = 0 ;
45302 char * kwnames[] = {
45303 (char *) "self",(char *) "border", NULL
45304 };
45305
45306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45308 if (!SWIG_IsOK(res1)) {
45309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45310 }
45311 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45312 ecode2 = SWIG_AsVal_int(obj1, &val2);
45313 if (!SWIG_IsOK(ecode2)) {
45314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45315 }
45316 arg2 = static_cast< int >(val2);
45317 {
45318 PyThreadState* __tstate = wxPyBeginAllowThreads();
45319 (arg1)->SetBorder(arg2);
45320 wxPyEndAllowThreads(__tstate);
45321 if (PyErr_Occurred()) SWIG_fail;
45322 }
45323 resultobj = SWIG_Py_Void();
45324 return resultobj;
45325 fail:
45326 return NULL;
45327 }
45328
45329
45330 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45331 PyObject *resultobj = 0;
45332 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45333 int result;
45334 void *argp1 = 0 ;
45335 int res1 = 0 ;
45336 PyObject *swig_obj[1] ;
45337
45338 if (!args) SWIG_fail;
45339 swig_obj[0] = args;
45340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45341 if (!SWIG_IsOK(res1)) {
45342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45343 }
45344 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45345 {
45346 PyThreadState* __tstate = wxPyBeginAllowThreads();
45347 result = (int)(arg1)->GetBorder();
45348 wxPyEndAllowThreads(__tstate);
45349 if (PyErr_Occurred()) SWIG_fail;
45350 }
45351 resultobj = SWIG_From_int(static_cast< int >(result));
45352 return resultobj;
45353 fail:
45354 return NULL;
45355 }
45356
45357
45358 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45359 PyObject *resultobj = 0;
45360 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45361 wxWindow *result = 0 ;
45362 void *argp1 = 0 ;
45363 int res1 = 0 ;
45364 PyObject *swig_obj[1] ;
45365
45366 if (!args) SWIG_fail;
45367 swig_obj[0] = args;
45368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45369 if (!SWIG_IsOK(res1)) {
45370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45371 }
45372 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45373 {
45374 PyThreadState* __tstate = wxPyBeginAllowThreads();
45375 result = (wxWindow *)(arg1)->GetWindow();
45376 wxPyEndAllowThreads(__tstate);
45377 if (PyErr_Occurred()) SWIG_fail;
45378 }
45379 {
45380 resultobj = wxPyMake_wxObject(result, 0);
45381 }
45382 return resultobj;
45383 fail:
45384 return NULL;
45385 }
45386
45387
45388 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45389 PyObject *resultobj = 0;
45390 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45391 wxWindow *arg2 = (wxWindow *) 0 ;
45392 void *argp1 = 0 ;
45393 int res1 = 0 ;
45394 void *argp2 = 0 ;
45395 int res2 = 0 ;
45396 PyObject * obj0 = 0 ;
45397 PyObject * obj1 = 0 ;
45398 char * kwnames[] = {
45399 (char *) "self",(char *) "window", NULL
45400 };
45401
45402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45404 if (!SWIG_IsOK(res1)) {
45405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45406 }
45407 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45409 if (!SWIG_IsOK(res2)) {
45410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45411 }
45412 arg2 = reinterpret_cast< wxWindow * >(argp2);
45413 {
45414 PyThreadState* __tstate = wxPyBeginAllowThreads();
45415 (arg1)->SetWindow(arg2);
45416 wxPyEndAllowThreads(__tstate);
45417 if (PyErr_Occurred()) SWIG_fail;
45418 }
45419 resultobj = SWIG_Py_Void();
45420 return resultobj;
45421 fail:
45422 return NULL;
45423 }
45424
45425
45426 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45427 PyObject *resultobj = 0;
45428 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45429 wxSizer *result = 0 ;
45430 void *argp1 = 0 ;
45431 int res1 = 0 ;
45432 PyObject *swig_obj[1] ;
45433
45434 if (!args) SWIG_fail;
45435 swig_obj[0] = args;
45436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45437 if (!SWIG_IsOK(res1)) {
45438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45439 }
45440 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45441 {
45442 PyThreadState* __tstate = wxPyBeginAllowThreads();
45443 result = (wxSizer *)(arg1)->GetSizer();
45444 wxPyEndAllowThreads(__tstate);
45445 if (PyErr_Occurred()) SWIG_fail;
45446 }
45447 {
45448 resultobj = wxPyMake_wxObject(result, (bool)0);
45449 }
45450 return resultobj;
45451 fail:
45452 return NULL;
45453 }
45454
45455
45456 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45457 PyObject *resultobj = 0;
45458 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45459 wxSizer *arg2 = (wxSizer *) 0 ;
45460 void *argp1 = 0 ;
45461 int res1 = 0 ;
45462 int res2 = 0 ;
45463 PyObject * obj0 = 0 ;
45464 PyObject * obj1 = 0 ;
45465 char * kwnames[] = {
45466 (char *) "self",(char *) "sizer", NULL
45467 };
45468
45469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45471 if (!SWIG_IsOK(res1)) {
45472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45473 }
45474 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45475 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45476 if (!SWIG_IsOK(res2)) {
45477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45478 }
45479 {
45480 PyThreadState* __tstate = wxPyBeginAllowThreads();
45481 (arg1)->SetSizer(arg2);
45482 wxPyEndAllowThreads(__tstate);
45483 if (PyErr_Occurred()) SWIG_fail;
45484 }
45485 resultobj = SWIG_Py_Void();
45486 return resultobj;
45487 fail:
45488 return NULL;
45489 }
45490
45491
45492 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45493 PyObject *resultobj = 0;
45494 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45495 wxSize *result = 0 ;
45496 void *argp1 = 0 ;
45497 int res1 = 0 ;
45498 PyObject *swig_obj[1] ;
45499
45500 if (!args) SWIG_fail;
45501 swig_obj[0] = args;
45502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45503 if (!SWIG_IsOK(res1)) {
45504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45505 }
45506 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45507 {
45508 PyThreadState* __tstate = wxPyBeginAllowThreads();
45509 {
45510 wxSize const &_result_ref = (arg1)->GetSpacer();
45511 result = (wxSize *) &_result_ref;
45512 }
45513 wxPyEndAllowThreads(__tstate);
45514 if (PyErr_Occurred()) SWIG_fail;
45515 }
45516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45517 return resultobj;
45518 fail:
45519 return NULL;
45520 }
45521
45522
45523 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45524 PyObject *resultobj = 0;
45525 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45526 wxSize *arg2 = 0 ;
45527 void *argp1 = 0 ;
45528 int res1 = 0 ;
45529 wxSize temp2 ;
45530 PyObject * obj0 = 0 ;
45531 PyObject * obj1 = 0 ;
45532 char * kwnames[] = {
45533 (char *) "self",(char *) "size", NULL
45534 };
45535
45536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45538 if (!SWIG_IsOK(res1)) {
45539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45540 }
45541 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45542 {
45543 arg2 = &temp2;
45544 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45545 }
45546 {
45547 PyThreadState* __tstate = wxPyBeginAllowThreads();
45548 (arg1)->SetSpacer((wxSize const &)*arg2);
45549 wxPyEndAllowThreads(__tstate);
45550 if (PyErr_Occurred()) SWIG_fail;
45551 }
45552 resultobj = SWIG_Py_Void();
45553 return resultobj;
45554 fail:
45555 return NULL;
45556 }
45557
45558
45559 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45560 PyObject *resultobj = 0;
45561 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45562 bool arg2 ;
45563 void *argp1 = 0 ;
45564 int res1 = 0 ;
45565 bool val2 ;
45566 int ecode2 = 0 ;
45567 PyObject * obj0 = 0 ;
45568 PyObject * obj1 = 0 ;
45569 char * kwnames[] = {
45570 (char *) "self",(char *) "show", NULL
45571 };
45572
45573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45575 if (!SWIG_IsOK(res1)) {
45576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45577 }
45578 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45579 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45580 if (!SWIG_IsOK(ecode2)) {
45581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45582 }
45583 arg2 = static_cast< bool >(val2);
45584 {
45585 PyThreadState* __tstate = wxPyBeginAllowThreads();
45586 (arg1)->Show(arg2);
45587 wxPyEndAllowThreads(__tstate);
45588 if (PyErr_Occurred()) SWIG_fail;
45589 }
45590 resultobj = SWIG_Py_Void();
45591 return resultobj;
45592 fail:
45593 return NULL;
45594 }
45595
45596
45597 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(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_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45610 }
45611 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45612 {
45613 PyThreadState* __tstate = wxPyBeginAllowThreads();
45614 result = (bool)(arg1)->IsShown();
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_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45628 PyObject *resultobj = 0;
45629 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45630 wxPoint 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_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45640 }
45641 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45642 {
45643 PyThreadState* __tstate = wxPyBeginAllowThreads();
45644 result = (arg1)->GetPosition();
45645 wxPyEndAllowThreads(__tstate);
45646 if (PyErr_Occurred()) SWIG_fail;
45647 }
45648 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45649 return resultobj;
45650 fail:
45651 return NULL;
45652 }
45653
45654
45655 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45656 PyObject *resultobj = 0;
45657 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45658 PyObject *result = 0 ;
45659 void *argp1 = 0 ;
45660 int res1 = 0 ;
45661 PyObject *swig_obj[1] ;
45662
45663 if (!args) SWIG_fail;
45664 swig_obj[0] = args;
45665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45666 if (!SWIG_IsOK(res1)) {
45667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45668 }
45669 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45670 {
45671 PyThreadState* __tstate = wxPyBeginAllowThreads();
45672 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45673 wxPyEndAllowThreads(__tstate);
45674 if (PyErr_Occurred()) SWIG_fail;
45675 }
45676 resultobj = result;
45677 return resultobj;
45678 fail:
45679 return NULL;
45680 }
45681
45682
45683 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45684 PyObject *resultobj = 0;
45685 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45686 PyObject *arg2 = (PyObject *) 0 ;
45687 void *argp1 = 0 ;
45688 int res1 = 0 ;
45689 PyObject * obj0 = 0 ;
45690 PyObject * obj1 = 0 ;
45691 char * kwnames[] = {
45692 (char *) "self",(char *) "userData", NULL
45693 };
45694
45695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45697 if (!SWIG_IsOK(res1)) {
45698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45699 }
45700 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45701 arg2 = obj1;
45702 {
45703 PyThreadState* __tstate = wxPyBeginAllowThreads();
45704 wxSizerItem_SetUserData(arg1,arg2);
45705 wxPyEndAllowThreads(__tstate);
45706 if (PyErr_Occurred()) SWIG_fail;
45707 }
45708 resultobj = SWIG_Py_Void();
45709 return resultobj;
45710 fail:
45711 return NULL;
45712 }
45713
45714
45715 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45716 PyObject *obj;
45717 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45718 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45719 return SWIG_Py_Void();
45720 }
45721
45722 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45723 return SWIG_Python_InitShadowInstance(args);
45724 }
45725
45726 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45727 PyObject *resultobj = 0;
45728 wxSizer *arg1 = (wxSizer *) 0 ;
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_wxSizer, SWIG_POINTER_DISOWN | 0 );
45736 if (!SWIG_IsOK(res1)) {
45737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45738 }
45739 arg1 = reinterpret_cast< wxSizer * >(argp1);
45740 {
45741 PyThreadState* __tstate = wxPyBeginAllowThreads();
45742 delete arg1;
45743
45744 wxPyEndAllowThreads(__tstate);
45745 if (PyErr_Occurred()) SWIG_fail;
45746 }
45747 resultobj = SWIG_Py_Void();
45748 return resultobj;
45749 fail:
45750 return NULL;
45751 }
45752
45753
45754 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45755 PyObject *resultobj = 0;
45756 wxSizer *arg1 = (wxSizer *) 0 ;
45757 PyObject *arg2 = (PyObject *) 0 ;
45758 void *argp1 = 0 ;
45759 int res1 = 0 ;
45760 PyObject * obj0 = 0 ;
45761 PyObject * obj1 = 0 ;
45762 char * kwnames[] = {
45763 (char *) "self",(char *) "_self", NULL
45764 };
45765
45766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
45767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45768 if (!SWIG_IsOK(res1)) {
45769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
45770 }
45771 arg1 = reinterpret_cast< wxSizer * >(argp1);
45772 arg2 = obj1;
45773 {
45774 PyThreadState* __tstate = wxPyBeginAllowThreads();
45775 wxSizer__setOORInfo(arg1,arg2);
45776 wxPyEndAllowThreads(__tstate);
45777 if (PyErr_Occurred()) SWIG_fail;
45778 }
45779 resultobj = SWIG_Py_Void();
45780 return resultobj;
45781 fail:
45782 return NULL;
45783 }
45784
45785
45786 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45787 PyObject *resultobj = 0;
45788 wxSizer *arg1 = (wxSizer *) 0 ;
45789 PyObject *arg2 = (PyObject *) 0 ;
45790 int arg3 = (int) 0 ;
45791 int arg4 = (int) 0 ;
45792 int arg5 = (int) 0 ;
45793 PyObject *arg6 = (PyObject *) NULL ;
45794 wxSizerItem *result = 0 ;
45795 void *argp1 = 0 ;
45796 int res1 = 0 ;
45797 int val3 ;
45798 int ecode3 = 0 ;
45799 int val4 ;
45800 int ecode4 = 0 ;
45801 int val5 ;
45802 int ecode5 = 0 ;
45803 PyObject * obj0 = 0 ;
45804 PyObject * obj1 = 0 ;
45805 PyObject * obj2 = 0 ;
45806 PyObject * obj3 = 0 ;
45807 PyObject * obj4 = 0 ;
45808 PyObject * obj5 = 0 ;
45809 char * kwnames[] = {
45810 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45811 };
45812
45813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45815 if (!SWIG_IsOK(res1)) {
45816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
45817 }
45818 arg1 = reinterpret_cast< wxSizer * >(argp1);
45819 arg2 = obj1;
45820 if (obj2) {
45821 ecode3 = SWIG_AsVal_int(obj2, &val3);
45822 if (!SWIG_IsOK(ecode3)) {
45823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
45824 }
45825 arg3 = static_cast< int >(val3);
45826 }
45827 if (obj3) {
45828 ecode4 = SWIG_AsVal_int(obj3, &val4);
45829 if (!SWIG_IsOK(ecode4)) {
45830 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
45831 }
45832 arg4 = static_cast< int >(val4);
45833 }
45834 if (obj4) {
45835 ecode5 = SWIG_AsVal_int(obj4, &val5);
45836 if (!SWIG_IsOK(ecode5)) {
45837 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
45838 }
45839 arg5 = static_cast< int >(val5);
45840 }
45841 if (obj5) {
45842 arg6 = obj5;
45843 }
45844 {
45845 PyThreadState* __tstate = wxPyBeginAllowThreads();
45846 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
45847 wxPyEndAllowThreads(__tstate);
45848 if (PyErr_Occurred()) SWIG_fail;
45849 }
45850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
45851 return resultobj;
45852 fail:
45853 return NULL;
45854 }
45855
45856
45857 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45858 PyObject *resultobj = 0;
45859 wxSizer *arg1 = (wxSizer *) 0 ;
45860 int arg2 ;
45861 PyObject *arg3 = (PyObject *) 0 ;
45862 int arg4 = (int) 0 ;
45863 int arg5 = (int) 0 ;
45864 int arg6 = (int) 0 ;
45865 PyObject *arg7 = (PyObject *) NULL ;
45866 wxSizerItem *result = 0 ;
45867 void *argp1 = 0 ;
45868 int res1 = 0 ;
45869 int val2 ;
45870 int ecode2 = 0 ;
45871 int val4 ;
45872 int ecode4 = 0 ;
45873 int val5 ;
45874 int ecode5 = 0 ;
45875 int val6 ;
45876 int ecode6 = 0 ;
45877 PyObject * obj0 = 0 ;
45878 PyObject * obj1 = 0 ;
45879 PyObject * obj2 = 0 ;
45880 PyObject * obj3 = 0 ;
45881 PyObject * obj4 = 0 ;
45882 PyObject * obj5 = 0 ;
45883 PyObject * obj6 = 0 ;
45884 char * kwnames[] = {
45885 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45886 };
45887
45888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45890 if (!SWIG_IsOK(res1)) {
45891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
45892 }
45893 arg1 = reinterpret_cast< wxSizer * >(argp1);
45894 ecode2 = SWIG_AsVal_int(obj1, &val2);
45895 if (!SWIG_IsOK(ecode2)) {
45896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
45897 }
45898 arg2 = static_cast< int >(val2);
45899 arg3 = obj2;
45900 if (obj3) {
45901 ecode4 = SWIG_AsVal_int(obj3, &val4);
45902 if (!SWIG_IsOK(ecode4)) {
45903 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
45904 }
45905 arg4 = static_cast< int >(val4);
45906 }
45907 if (obj4) {
45908 ecode5 = SWIG_AsVal_int(obj4, &val5);
45909 if (!SWIG_IsOK(ecode5)) {
45910 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
45911 }
45912 arg5 = static_cast< int >(val5);
45913 }
45914 if (obj5) {
45915 ecode6 = SWIG_AsVal_int(obj5, &val6);
45916 if (!SWIG_IsOK(ecode6)) {
45917 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
45918 }
45919 arg6 = static_cast< int >(val6);
45920 }
45921 if (obj6) {
45922 arg7 = obj6;
45923 }
45924 {
45925 PyThreadState* __tstate = wxPyBeginAllowThreads();
45926 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
45927 wxPyEndAllowThreads(__tstate);
45928 if (PyErr_Occurred()) SWIG_fail;
45929 }
45930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
45931 return resultobj;
45932 fail:
45933 return NULL;
45934 }
45935
45936
45937 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45938 PyObject *resultobj = 0;
45939 wxSizer *arg1 = (wxSizer *) 0 ;
45940 PyObject *arg2 = (PyObject *) 0 ;
45941 int arg3 = (int) 0 ;
45942 int arg4 = (int) 0 ;
45943 int arg5 = (int) 0 ;
45944 PyObject *arg6 = (PyObject *) NULL ;
45945 wxSizerItem *result = 0 ;
45946 void *argp1 = 0 ;
45947 int res1 = 0 ;
45948 int val3 ;
45949 int ecode3 = 0 ;
45950 int val4 ;
45951 int ecode4 = 0 ;
45952 int val5 ;
45953 int ecode5 = 0 ;
45954 PyObject * obj0 = 0 ;
45955 PyObject * obj1 = 0 ;
45956 PyObject * obj2 = 0 ;
45957 PyObject * obj3 = 0 ;
45958 PyObject * obj4 = 0 ;
45959 PyObject * obj5 = 0 ;
45960 char * kwnames[] = {
45961 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45962 };
45963
45964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45966 if (!SWIG_IsOK(res1)) {
45967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
45968 }
45969 arg1 = reinterpret_cast< wxSizer * >(argp1);
45970 arg2 = obj1;
45971 if (obj2) {
45972 ecode3 = SWIG_AsVal_int(obj2, &val3);
45973 if (!SWIG_IsOK(ecode3)) {
45974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
45975 }
45976 arg3 = static_cast< int >(val3);
45977 }
45978 if (obj3) {
45979 ecode4 = SWIG_AsVal_int(obj3, &val4);
45980 if (!SWIG_IsOK(ecode4)) {
45981 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
45982 }
45983 arg4 = static_cast< int >(val4);
45984 }
45985 if (obj4) {
45986 ecode5 = SWIG_AsVal_int(obj4, &val5);
45987 if (!SWIG_IsOK(ecode5)) {
45988 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
45989 }
45990 arg5 = static_cast< int >(val5);
45991 }
45992 if (obj5) {
45993 arg6 = obj5;
45994 }
45995 {
45996 PyThreadState* __tstate = wxPyBeginAllowThreads();
45997 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
45998 wxPyEndAllowThreads(__tstate);
45999 if (PyErr_Occurred()) SWIG_fail;
46000 }
46001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46002 return resultobj;
46003 fail:
46004 return NULL;
46005 }
46006
46007
46008 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46009 PyObject *resultobj = 0;
46010 wxSizer *arg1 = (wxSizer *) 0 ;
46011 PyObject *arg2 = (PyObject *) 0 ;
46012 bool result;
46013 void *argp1 = 0 ;
46014 int res1 = 0 ;
46015 PyObject * obj0 = 0 ;
46016 PyObject * obj1 = 0 ;
46017 char * kwnames[] = {
46018 (char *) "self",(char *) "item", NULL
46019 };
46020
46021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46023 if (!SWIG_IsOK(res1)) {
46024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46025 }
46026 arg1 = reinterpret_cast< wxSizer * >(argp1);
46027 arg2 = obj1;
46028 {
46029 PyThreadState* __tstate = wxPyBeginAllowThreads();
46030 result = (bool)wxSizer_Remove(arg1,arg2);
46031 wxPyEndAllowThreads(__tstate);
46032 if (PyErr_Occurred()) SWIG_fail;
46033 }
46034 {
46035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46036 }
46037 return resultobj;
46038 fail:
46039 return NULL;
46040 }
46041
46042
46043 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46044 PyObject *resultobj = 0;
46045 wxSizer *arg1 = (wxSizer *) 0 ;
46046 PyObject *arg2 = (PyObject *) 0 ;
46047 bool result;
46048 void *argp1 = 0 ;
46049 int res1 = 0 ;
46050 PyObject * obj0 = 0 ;
46051 PyObject * obj1 = 0 ;
46052 char * kwnames[] = {
46053 (char *) "self",(char *) "item", NULL
46054 };
46055
46056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46058 if (!SWIG_IsOK(res1)) {
46059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46060 }
46061 arg1 = reinterpret_cast< wxSizer * >(argp1);
46062 arg2 = obj1;
46063 {
46064 PyThreadState* __tstate = wxPyBeginAllowThreads();
46065 result = (bool)wxSizer_Detach(arg1,arg2);
46066 wxPyEndAllowThreads(__tstate);
46067 if (PyErr_Occurred()) SWIG_fail;
46068 }
46069 {
46070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46071 }
46072 return resultobj;
46073 fail:
46074 return NULL;
46075 }
46076
46077
46078 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46079 PyObject *resultobj = 0;
46080 wxSizer *arg1 = (wxSizer *) 0 ;
46081 PyObject *arg2 = (PyObject *) 0 ;
46082 wxSizerItem *result = 0 ;
46083 void *argp1 = 0 ;
46084 int res1 = 0 ;
46085 PyObject * obj0 = 0 ;
46086 PyObject * obj1 = 0 ;
46087 char * kwnames[] = {
46088 (char *) "self",(char *) "item", NULL
46089 };
46090
46091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46093 if (!SWIG_IsOK(res1)) {
46094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46095 }
46096 arg1 = reinterpret_cast< wxSizer * >(argp1);
46097 arg2 = obj1;
46098 {
46099 PyThreadState* __tstate = wxPyBeginAllowThreads();
46100 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46101 wxPyEndAllowThreads(__tstate);
46102 if (PyErr_Occurred()) SWIG_fail;
46103 }
46104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46105 return resultobj;
46106 fail:
46107 return NULL;
46108 }
46109
46110
46111 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46112 PyObject *resultobj = 0;
46113 wxSizer *arg1 = (wxSizer *) 0 ;
46114 PyObject *arg2 = (PyObject *) 0 ;
46115 wxSize *arg3 = 0 ;
46116 void *argp1 = 0 ;
46117 int res1 = 0 ;
46118 wxSize temp3 ;
46119 PyObject * obj0 = 0 ;
46120 PyObject * obj1 = 0 ;
46121 PyObject * obj2 = 0 ;
46122 char * kwnames[] = {
46123 (char *) "self",(char *) "item",(char *) "size", NULL
46124 };
46125
46126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46128 if (!SWIG_IsOK(res1)) {
46129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46130 }
46131 arg1 = reinterpret_cast< wxSizer * >(argp1);
46132 arg2 = obj1;
46133 {
46134 arg3 = &temp3;
46135 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46136 }
46137 {
46138 PyThreadState* __tstate = wxPyBeginAllowThreads();
46139 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46140 wxPyEndAllowThreads(__tstate);
46141 if (PyErr_Occurred()) SWIG_fail;
46142 }
46143 resultobj = SWIG_Py_Void();
46144 return resultobj;
46145 fail:
46146 return NULL;
46147 }
46148
46149
46150 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46151 PyObject *resultobj = 0;
46152 wxSizer *arg1 = (wxSizer *) 0 ;
46153 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46154 wxSizerItem *result = 0 ;
46155 void *argp1 = 0 ;
46156 int res1 = 0 ;
46157 int res2 = 0 ;
46158 PyObject * obj0 = 0 ;
46159 PyObject * obj1 = 0 ;
46160 char * kwnames[] = {
46161 (char *) "self",(char *) "item", NULL
46162 };
46163
46164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46166 if (!SWIG_IsOK(res1)) {
46167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46168 }
46169 arg1 = reinterpret_cast< wxSizer * >(argp1);
46170 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46171 if (!SWIG_IsOK(res2)) {
46172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46173 }
46174 {
46175 PyThreadState* __tstate = wxPyBeginAllowThreads();
46176 result = (wxSizerItem *)(arg1)->Add(arg2);
46177 wxPyEndAllowThreads(__tstate);
46178 if (PyErr_Occurred()) SWIG_fail;
46179 }
46180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46181 return resultobj;
46182 fail:
46183 return NULL;
46184 }
46185
46186
46187 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46188 PyObject *resultobj = 0;
46189 wxSizer *arg1 = (wxSizer *) 0 ;
46190 size_t arg2 ;
46191 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46192 wxSizerItem *result = 0 ;
46193 void *argp1 = 0 ;
46194 int res1 = 0 ;
46195 size_t val2 ;
46196 int ecode2 = 0 ;
46197 int res3 = 0 ;
46198 PyObject * obj0 = 0 ;
46199 PyObject * obj1 = 0 ;
46200 PyObject * obj2 = 0 ;
46201 char * kwnames[] = {
46202 (char *) "self",(char *) "index",(char *) "item", NULL
46203 };
46204
46205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46207 if (!SWIG_IsOK(res1)) {
46208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46209 }
46210 arg1 = reinterpret_cast< wxSizer * >(argp1);
46211 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46212 if (!SWIG_IsOK(ecode2)) {
46213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46214 }
46215 arg2 = static_cast< size_t >(val2);
46216 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46217 if (!SWIG_IsOK(res3)) {
46218 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46219 }
46220 {
46221 PyThreadState* __tstate = wxPyBeginAllowThreads();
46222 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46223 wxPyEndAllowThreads(__tstate);
46224 if (PyErr_Occurred()) SWIG_fail;
46225 }
46226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46227 return resultobj;
46228 fail:
46229 return NULL;
46230 }
46231
46232
46233 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46234 PyObject *resultobj = 0;
46235 wxSizer *arg1 = (wxSizer *) 0 ;
46236 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46237 wxSizerItem *result = 0 ;
46238 void *argp1 = 0 ;
46239 int res1 = 0 ;
46240 int res2 = 0 ;
46241 PyObject * obj0 = 0 ;
46242 PyObject * obj1 = 0 ;
46243 char * kwnames[] = {
46244 (char *) "self",(char *) "item", NULL
46245 };
46246
46247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46249 if (!SWIG_IsOK(res1)) {
46250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46251 }
46252 arg1 = reinterpret_cast< wxSizer * >(argp1);
46253 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46254 if (!SWIG_IsOK(res2)) {
46255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46256 }
46257 {
46258 PyThreadState* __tstate = wxPyBeginAllowThreads();
46259 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46260 wxPyEndAllowThreads(__tstate);
46261 if (PyErr_Occurred()) SWIG_fail;
46262 }
46263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46264 return resultobj;
46265 fail:
46266 return NULL;
46267 }
46268
46269
46270 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46271 PyObject *resultobj = 0;
46272 wxSizer *arg1 = (wxSizer *) 0 ;
46273 int arg2 ;
46274 int arg3 ;
46275 int arg4 ;
46276 int arg5 ;
46277 void *argp1 = 0 ;
46278 int res1 = 0 ;
46279 int val2 ;
46280 int ecode2 = 0 ;
46281 int val3 ;
46282 int ecode3 = 0 ;
46283 int val4 ;
46284 int ecode4 = 0 ;
46285 int val5 ;
46286 int ecode5 = 0 ;
46287 PyObject * obj0 = 0 ;
46288 PyObject * obj1 = 0 ;
46289 PyObject * obj2 = 0 ;
46290 PyObject * obj3 = 0 ;
46291 PyObject * obj4 = 0 ;
46292 char * kwnames[] = {
46293 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46294 };
46295
46296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46298 if (!SWIG_IsOK(res1)) {
46299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46300 }
46301 arg1 = reinterpret_cast< wxSizer * >(argp1);
46302 ecode2 = SWIG_AsVal_int(obj1, &val2);
46303 if (!SWIG_IsOK(ecode2)) {
46304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46305 }
46306 arg2 = static_cast< int >(val2);
46307 ecode3 = SWIG_AsVal_int(obj2, &val3);
46308 if (!SWIG_IsOK(ecode3)) {
46309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46310 }
46311 arg3 = static_cast< int >(val3);
46312 ecode4 = SWIG_AsVal_int(obj3, &val4);
46313 if (!SWIG_IsOK(ecode4)) {
46314 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46315 }
46316 arg4 = static_cast< int >(val4);
46317 ecode5 = SWIG_AsVal_int(obj4, &val5);
46318 if (!SWIG_IsOK(ecode5)) {
46319 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46320 }
46321 arg5 = static_cast< int >(val5);
46322 {
46323 PyThreadState* __tstate = wxPyBeginAllowThreads();
46324 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46325 wxPyEndAllowThreads(__tstate);
46326 if (PyErr_Occurred()) SWIG_fail;
46327 }
46328 resultobj = SWIG_Py_Void();
46329 return resultobj;
46330 fail:
46331 return NULL;
46332 }
46333
46334
46335 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46336 PyObject *resultobj = 0;
46337 wxSizer *arg1 = (wxSizer *) 0 ;
46338 wxSize *arg2 = 0 ;
46339 void *argp1 = 0 ;
46340 int res1 = 0 ;
46341 wxSize temp2 ;
46342 PyObject * obj0 = 0 ;
46343 PyObject * obj1 = 0 ;
46344 char * kwnames[] = {
46345 (char *) "self",(char *) "size", NULL
46346 };
46347
46348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46350 if (!SWIG_IsOK(res1)) {
46351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46352 }
46353 arg1 = reinterpret_cast< wxSizer * >(argp1);
46354 {
46355 arg2 = &temp2;
46356 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46357 }
46358 {
46359 PyThreadState* __tstate = wxPyBeginAllowThreads();
46360 (arg1)->SetMinSize((wxSize const &)*arg2);
46361 wxPyEndAllowThreads(__tstate);
46362 if (PyErr_Occurred()) SWIG_fail;
46363 }
46364 resultobj = SWIG_Py_Void();
46365 return resultobj;
46366 fail:
46367 return NULL;
46368 }
46369
46370
46371 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46372 PyObject *resultobj = 0;
46373 wxSizer *arg1 = (wxSizer *) 0 ;
46374 wxSize result;
46375 void *argp1 = 0 ;
46376 int res1 = 0 ;
46377 PyObject *swig_obj[1] ;
46378
46379 if (!args) SWIG_fail;
46380 swig_obj[0] = args;
46381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46382 if (!SWIG_IsOK(res1)) {
46383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46384 }
46385 arg1 = reinterpret_cast< wxSizer * >(argp1);
46386 {
46387 PyThreadState* __tstate = wxPyBeginAllowThreads();
46388 result = (arg1)->GetSize();
46389 wxPyEndAllowThreads(__tstate);
46390 if (PyErr_Occurred()) SWIG_fail;
46391 }
46392 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46393 return resultobj;
46394 fail:
46395 return NULL;
46396 }
46397
46398
46399 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46400 PyObject *resultobj = 0;
46401 wxSizer *arg1 = (wxSizer *) 0 ;
46402 wxPoint result;
46403 void *argp1 = 0 ;
46404 int res1 = 0 ;
46405 PyObject *swig_obj[1] ;
46406
46407 if (!args) SWIG_fail;
46408 swig_obj[0] = args;
46409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46410 if (!SWIG_IsOK(res1)) {
46411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46412 }
46413 arg1 = reinterpret_cast< wxSizer * >(argp1);
46414 {
46415 PyThreadState* __tstate = wxPyBeginAllowThreads();
46416 result = (arg1)->GetPosition();
46417 wxPyEndAllowThreads(__tstate);
46418 if (PyErr_Occurred()) SWIG_fail;
46419 }
46420 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46421 return resultobj;
46422 fail:
46423 return NULL;
46424 }
46425
46426
46427 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46428 PyObject *resultobj = 0;
46429 wxSizer *arg1 = (wxSizer *) 0 ;
46430 wxSize result;
46431 void *argp1 = 0 ;
46432 int res1 = 0 ;
46433 PyObject *swig_obj[1] ;
46434
46435 if (!args) SWIG_fail;
46436 swig_obj[0] = args;
46437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46438 if (!SWIG_IsOK(res1)) {
46439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46440 }
46441 arg1 = reinterpret_cast< wxSizer * >(argp1);
46442 {
46443 PyThreadState* __tstate = wxPyBeginAllowThreads();
46444 result = (arg1)->GetMinSize();
46445 wxPyEndAllowThreads(__tstate);
46446 if (PyErr_Occurred()) SWIG_fail;
46447 }
46448 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46449 return resultobj;
46450 fail:
46451 return NULL;
46452 }
46453
46454
46455 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46456 PyObject *resultobj = 0;
46457 wxSizer *arg1 = (wxSizer *) 0 ;
46458 void *argp1 = 0 ;
46459 int res1 = 0 ;
46460 PyObject *swig_obj[1] ;
46461
46462 if (!args) SWIG_fail;
46463 swig_obj[0] = args;
46464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46465 if (!SWIG_IsOK(res1)) {
46466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46467 }
46468 arg1 = reinterpret_cast< wxSizer * >(argp1);
46469 {
46470 PyThreadState* __tstate = wxPyBeginAllowThreads();
46471 (arg1)->RecalcSizes();
46472 wxPyEndAllowThreads(__tstate);
46473 if (PyErr_Occurred()) SWIG_fail;
46474 }
46475 resultobj = SWIG_Py_Void();
46476 return resultobj;
46477 fail:
46478 return NULL;
46479 }
46480
46481
46482 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46483 PyObject *resultobj = 0;
46484 wxSizer *arg1 = (wxSizer *) 0 ;
46485 wxSize result;
46486 void *argp1 = 0 ;
46487 int res1 = 0 ;
46488 PyObject *swig_obj[1] ;
46489
46490 if (!args) SWIG_fail;
46491 swig_obj[0] = args;
46492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46493 if (!SWIG_IsOK(res1)) {
46494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46495 }
46496 arg1 = reinterpret_cast< wxSizer * >(argp1);
46497 {
46498 PyThreadState* __tstate = wxPyBeginAllowThreads();
46499 result = (arg1)->CalcMin();
46500 wxPyEndAllowThreads(__tstate);
46501 if (PyErr_Occurred()) SWIG_fail;
46502 }
46503 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46504 return resultobj;
46505 fail:
46506 return NULL;
46507 }
46508
46509
46510 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46511 PyObject *resultobj = 0;
46512 wxSizer *arg1 = (wxSizer *) 0 ;
46513 void *argp1 = 0 ;
46514 int res1 = 0 ;
46515 PyObject *swig_obj[1] ;
46516
46517 if (!args) SWIG_fail;
46518 swig_obj[0] = args;
46519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46520 if (!SWIG_IsOK(res1)) {
46521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46522 }
46523 arg1 = reinterpret_cast< wxSizer * >(argp1);
46524 {
46525 PyThreadState* __tstate = wxPyBeginAllowThreads();
46526 (arg1)->Layout();
46527 wxPyEndAllowThreads(__tstate);
46528 if (PyErr_Occurred()) SWIG_fail;
46529 }
46530 resultobj = SWIG_Py_Void();
46531 return resultobj;
46532 fail:
46533 return NULL;
46534 }
46535
46536
46537 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46538 PyObject *resultobj = 0;
46539 wxSizer *arg1 = (wxSizer *) 0 ;
46540 wxWindow *arg2 = (wxWindow *) 0 ;
46541 wxSize result;
46542 void *argp1 = 0 ;
46543 int res1 = 0 ;
46544 void *argp2 = 0 ;
46545 int res2 = 0 ;
46546 PyObject * obj0 = 0 ;
46547 PyObject * obj1 = 0 ;
46548 char * kwnames[] = {
46549 (char *) "self",(char *) "window", NULL
46550 };
46551
46552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46554 if (!SWIG_IsOK(res1)) {
46555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46556 }
46557 arg1 = reinterpret_cast< wxSizer * >(argp1);
46558 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46559 if (!SWIG_IsOK(res2)) {
46560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46561 }
46562 arg2 = reinterpret_cast< wxWindow * >(argp2);
46563 {
46564 PyThreadState* __tstate = wxPyBeginAllowThreads();
46565 result = (arg1)->Fit(arg2);
46566 wxPyEndAllowThreads(__tstate);
46567 if (PyErr_Occurred()) SWIG_fail;
46568 }
46569 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46570 return resultobj;
46571 fail:
46572 return NULL;
46573 }
46574
46575
46576 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46577 PyObject *resultobj = 0;
46578 wxSizer *arg1 = (wxSizer *) 0 ;
46579 wxWindow *arg2 = (wxWindow *) 0 ;
46580 void *argp1 = 0 ;
46581 int res1 = 0 ;
46582 void *argp2 = 0 ;
46583 int res2 = 0 ;
46584 PyObject * obj0 = 0 ;
46585 PyObject * obj1 = 0 ;
46586 char * kwnames[] = {
46587 (char *) "self",(char *) "window", NULL
46588 };
46589
46590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46592 if (!SWIG_IsOK(res1)) {
46593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46594 }
46595 arg1 = reinterpret_cast< wxSizer * >(argp1);
46596 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46597 if (!SWIG_IsOK(res2)) {
46598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46599 }
46600 arg2 = reinterpret_cast< wxWindow * >(argp2);
46601 {
46602 PyThreadState* __tstate = wxPyBeginAllowThreads();
46603 (arg1)->FitInside(arg2);
46604 wxPyEndAllowThreads(__tstate);
46605 if (PyErr_Occurred()) SWIG_fail;
46606 }
46607 resultobj = SWIG_Py_Void();
46608 return resultobj;
46609 fail:
46610 return NULL;
46611 }
46612
46613
46614 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46615 PyObject *resultobj = 0;
46616 wxSizer *arg1 = (wxSizer *) 0 ;
46617 wxWindow *arg2 = (wxWindow *) 0 ;
46618 void *argp1 = 0 ;
46619 int res1 = 0 ;
46620 void *argp2 = 0 ;
46621 int res2 = 0 ;
46622 PyObject * obj0 = 0 ;
46623 PyObject * obj1 = 0 ;
46624 char * kwnames[] = {
46625 (char *) "self",(char *) "window", NULL
46626 };
46627
46628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46630 if (!SWIG_IsOK(res1)) {
46631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46632 }
46633 arg1 = reinterpret_cast< wxSizer * >(argp1);
46634 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46635 if (!SWIG_IsOK(res2)) {
46636 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46637 }
46638 arg2 = reinterpret_cast< wxWindow * >(argp2);
46639 {
46640 PyThreadState* __tstate = wxPyBeginAllowThreads();
46641 (arg1)->SetSizeHints(arg2);
46642 wxPyEndAllowThreads(__tstate);
46643 if (PyErr_Occurred()) SWIG_fail;
46644 }
46645 resultobj = SWIG_Py_Void();
46646 return resultobj;
46647 fail:
46648 return NULL;
46649 }
46650
46651
46652 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46653 PyObject *resultobj = 0;
46654 wxSizer *arg1 = (wxSizer *) 0 ;
46655 wxWindow *arg2 = (wxWindow *) 0 ;
46656 void *argp1 = 0 ;
46657 int res1 = 0 ;
46658 void *argp2 = 0 ;
46659 int res2 = 0 ;
46660 PyObject * obj0 = 0 ;
46661 PyObject * obj1 = 0 ;
46662 char * kwnames[] = {
46663 (char *) "self",(char *) "window", NULL
46664 };
46665
46666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46668 if (!SWIG_IsOK(res1)) {
46669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46670 }
46671 arg1 = reinterpret_cast< wxSizer * >(argp1);
46672 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46673 if (!SWIG_IsOK(res2)) {
46674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46675 }
46676 arg2 = reinterpret_cast< wxWindow * >(argp2);
46677 {
46678 PyThreadState* __tstate = wxPyBeginAllowThreads();
46679 (arg1)->SetVirtualSizeHints(arg2);
46680 wxPyEndAllowThreads(__tstate);
46681 if (PyErr_Occurred()) SWIG_fail;
46682 }
46683 resultobj = SWIG_Py_Void();
46684 return resultobj;
46685 fail:
46686 return NULL;
46687 }
46688
46689
46690 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46691 PyObject *resultobj = 0;
46692 wxSizer *arg1 = (wxSizer *) 0 ;
46693 bool arg2 = (bool) false ;
46694 void *argp1 = 0 ;
46695 int res1 = 0 ;
46696 bool val2 ;
46697 int ecode2 = 0 ;
46698 PyObject * obj0 = 0 ;
46699 PyObject * obj1 = 0 ;
46700 char * kwnames[] = {
46701 (char *) "self",(char *) "deleteWindows", NULL
46702 };
46703
46704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46706 if (!SWIG_IsOK(res1)) {
46707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46708 }
46709 arg1 = reinterpret_cast< wxSizer * >(argp1);
46710 if (obj1) {
46711 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46712 if (!SWIG_IsOK(ecode2)) {
46713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46714 }
46715 arg2 = static_cast< bool >(val2);
46716 }
46717 {
46718 PyThreadState* __tstate = wxPyBeginAllowThreads();
46719 (arg1)->Clear(arg2);
46720 wxPyEndAllowThreads(__tstate);
46721 if (PyErr_Occurred()) SWIG_fail;
46722 }
46723 resultobj = SWIG_Py_Void();
46724 return resultobj;
46725 fail:
46726 return NULL;
46727 }
46728
46729
46730 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46731 PyObject *resultobj = 0;
46732 wxSizer *arg1 = (wxSizer *) 0 ;
46733 void *argp1 = 0 ;
46734 int res1 = 0 ;
46735 PyObject *swig_obj[1] ;
46736
46737 if (!args) SWIG_fail;
46738 swig_obj[0] = args;
46739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46740 if (!SWIG_IsOK(res1)) {
46741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
46742 }
46743 arg1 = reinterpret_cast< wxSizer * >(argp1);
46744 {
46745 PyThreadState* __tstate = wxPyBeginAllowThreads();
46746 (arg1)->DeleteWindows();
46747 wxPyEndAllowThreads(__tstate);
46748 if (PyErr_Occurred()) SWIG_fail;
46749 }
46750 resultobj = SWIG_Py_Void();
46751 return resultobj;
46752 fail:
46753 return NULL;
46754 }
46755
46756
46757 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46758 PyObject *resultobj = 0;
46759 wxSizer *arg1 = (wxSizer *) 0 ;
46760 PyObject *result = 0 ;
46761 void *argp1 = 0 ;
46762 int res1 = 0 ;
46763 PyObject *swig_obj[1] ;
46764
46765 if (!args) SWIG_fail;
46766 swig_obj[0] = args;
46767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46768 if (!SWIG_IsOK(res1)) {
46769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
46770 }
46771 arg1 = reinterpret_cast< wxSizer * >(argp1);
46772 {
46773 PyThreadState* __tstate = wxPyBeginAllowThreads();
46774 result = (PyObject *)wxSizer_GetChildren(arg1);
46775 wxPyEndAllowThreads(__tstate);
46776 if (PyErr_Occurred()) SWIG_fail;
46777 }
46778 resultobj = result;
46779 return resultobj;
46780 fail:
46781 return NULL;
46782 }
46783
46784
46785 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46786 PyObject *resultobj = 0;
46787 wxSizer *arg1 = (wxSizer *) 0 ;
46788 PyObject *arg2 = (PyObject *) 0 ;
46789 bool arg3 = (bool) true ;
46790 bool arg4 = (bool) false ;
46791 bool result;
46792 void *argp1 = 0 ;
46793 int res1 = 0 ;
46794 bool val3 ;
46795 int ecode3 = 0 ;
46796 bool val4 ;
46797 int ecode4 = 0 ;
46798 PyObject * obj0 = 0 ;
46799 PyObject * obj1 = 0 ;
46800 PyObject * obj2 = 0 ;
46801 PyObject * obj3 = 0 ;
46802 char * kwnames[] = {
46803 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
46804 };
46805
46806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
46807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46808 if (!SWIG_IsOK(res1)) {
46809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
46810 }
46811 arg1 = reinterpret_cast< wxSizer * >(argp1);
46812 arg2 = obj1;
46813 if (obj2) {
46814 ecode3 = SWIG_AsVal_bool(obj2, &val3);
46815 if (!SWIG_IsOK(ecode3)) {
46816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
46817 }
46818 arg3 = static_cast< bool >(val3);
46819 }
46820 if (obj3) {
46821 ecode4 = SWIG_AsVal_bool(obj3, &val4);
46822 if (!SWIG_IsOK(ecode4)) {
46823 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
46824 }
46825 arg4 = static_cast< bool >(val4);
46826 }
46827 {
46828 PyThreadState* __tstate = wxPyBeginAllowThreads();
46829 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
46830 wxPyEndAllowThreads(__tstate);
46831 if (PyErr_Occurred()) SWIG_fail;
46832 }
46833 {
46834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46835 }
46836 return resultobj;
46837 fail:
46838 return NULL;
46839 }
46840
46841
46842 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46843 PyObject *resultobj = 0;
46844 wxSizer *arg1 = (wxSizer *) 0 ;
46845 PyObject *arg2 = (PyObject *) 0 ;
46846 bool result;
46847 void *argp1 = 0 ;
46848 int res1 = 0 ;
46849 PyObject * obj0 = 0 ;
46850 PyObject * obj1 = 0 ;
46851 char * kwnames[] = {
46852 (char *) "self",(char *) "item", NULL
46853 };
46854
46855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
46856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46857 if (!SWIG_IsOK(res1)) {
46858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
46859 }
46860 arg1 = reinterpret_cast< wxSizer * >(argp1);
46861 arg2 = obj1;
46862 {
46863 PyThreadState* __tstate = wxPyBeginAllowThreads();
46864 result = (bool)wxSizer_IsShown(arg1,arg2);
46865 wxPyEndAllowThreads(__tstate);
46866 if (PyErr_Occurred()) SWIG_fail;
46867 }
46868 {
46869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46870 }
46871 return resultobj;
46872 fail:
46873 return NULL;
46874 }
46875
46876
46877 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46878 PyObject *resultobj = 0;
46879 wxSizer *arg1 = (wxSizer *) 0 ;
46880 bool arg2 ;
46881 void *argp1 = 0 ;
46882 int res1 = 0 ;
46883 bool val2 ;
46884 int ecode2 = 0 ;
46885 PyObject * obj0 = 0 ;
46886 PyObject * obj1 = 0 ;
46887 char * kwnames[] = {
46888 (char *) "self",(char *) "show", NULL
46889 };
46890
46891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
46892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46893 if (!SWIG_IsOK(res1)) {
46894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
46895 }
46896 arg1 = reinterpret_cast< wxSizer * >(argp1);
46897 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46898 if (!SWIG_IsOK(ecode2)) {
46899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
46900 }
46901 arg2 = static_cast< bool >(val2);
46902 {
46903 PyThreadState* __tstate = wxPyBeginAllowThreads();
46904 (arg1)->ShowItems(arg2);
46905 wxPyEndAllowThreads(__tstate);
46906 if (PyErr_Occurred()) SWIG_fail;
46907 }
46908 resultobj = SWIG_Py_Void();
46909 return resultobj;
46910 fail:
46911 return NULL;
46912 }
46913
46914
46915 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46916 PyObject *obj;
46917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46918 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
46919 return SWIG_Py_Void();
46920 }
46921
46922 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46923 PyObject *resultobj = 0;
46924 wxPySizer *result = 0 ;
46925
46926 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
46927 {
46928 PyThreadState* __tstate = wxPyBeginAllowThreads();
46929 result = (wxPySizer *)new wxPySizer();
46930 wxPyEndAllowThreads(__tstate);
46931 if (PyErr_Occurred()) SWIG_fail;
46932 }
46933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
46934 return resultobj;
46935 fail:
46936 return NULL;
46937 }
46938
46939
46940 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46941 PyObject *resultobj = 0;
46942 wxPySizer *arg1 = (wxPySizer *) 0 ;
46943 PyObject *arg2 = (PyObject *) 0 ;
46944 PyObject *arg3 = (PyObject *) 0 ;
46945 void *argp1 = 0 ;
46946 int res1 = 0 ;
46947 PyObject * obj0 = 0 ;
46948 PyObject * obj1 = 0 ;
46949 PyObject * obj2 = 0 ;
46950 char * kwnames[] = {
46951 (char *) "self",(char *) "self",(char *) "_class", NULL
46952 };
46953
46954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
46956 if (!SWIG_IsOK(res1)) {
46957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
46958 }
46959 arg1 = reinterpret_cast< wxPySizer * >(argp1);
46960 arg2 = obj1;
46961 arg3 = obj2;
46962 {
46963 PyThreadState* __tstate = wxPyBeginAllowThreads();
46964 (arg1)->_setCallbackInfo(arg2,arg3);
46965 wxPyEndAllowThreads(__tstate);
46966 if (PyErr_Occurred()) SWIG_fail;
46967 }
46968 resultobj = SWIG_Py_Void();
46969 return resultobj;
46970 fail:
46971 return NULL;
46972 }
46973
46974
46975 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46976 PyObject *obj;
46977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46978 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
46979 return SWIG_Py_Void();
46980 }
46981
46982 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46983 return SWIG_Python_InitShadowInstance(args);
46984 }
46985
46986 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46987 PyObject *resultobj = 0;
46988 int arg1 = (int) wxHORIZONTAL ;
46989 wxBoxSizer *result = 0 ;
46990 int val1 ;
46991 int ecode1 = 0 ;
46992 PyObject * obj0 = 0 ;
46993 char * kwnames[] = {
46994 (char *) "orient", NULL
46995 };
46996
46997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
46998 if (obj0) {
46999 ecode1 = SWIG_AsVal_int(obj0, &val1);
47000 if (!SWIG_IsOK(ecode1)) {
47001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47002 }
47003 arg1 = static_cast< int >(val1);
47004 }
47005 {
47006 PyThreadState* __tstate = wxPyBeginAllowThreads();
47007 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47008 wxPyEndAllowThreads(__tstate);
47009 if (PyErr_Occurred()) SWIG_fail;
47010 }
47011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47012 return resultobj;
47013 fail:
47014 return NULL;
47015 }
47016
47017
47018 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47019 PyObject *resultobj = 0;
47020 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47021 int result;
47022 void *argp1 = 0 ;
47023 int res1 = 0 ;
47024 PyObject *swig_obj[1] ;
47025
47026 if (!args) SWIG_fail;
47027 swig_obj[0] = args;
47028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47029 if (!SWIG_IsOK(res1)) {
47030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47031 }
47032 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47033 {
47034 PyThreadState* __tstate = wxPyBeginAllowThreads();
47035 result = (int)(arg1)->GetOrientation();
47036 wxPyEndAllowThreads(__tstate);
47037 if (PyErr_Occurred()) SWIG_fail;
47038 }
47039 resultobj = SWIG_From_int(static_cast< int >(result));
47040 return resultobj;
47041 fail:
47042 return NULL;
47043 }
47044
47045
47046 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47047 PyObject *resultobj = 0;
47048 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47049 int arg2 ;
47050 void *argp1 = 0 ;
47051 int res1 = 0 ;
47052 int val2 ;
47053 int ecode2 = 0 ;
47054 PyObject * obj0 = 0 ;
47055 PyObject * obj1 = 0 ;
47056 char * kwnames[] = {
47057 (char *) "self",(char *) "orient", NULL
47058 };
47059
47060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47062 if (!SWIG_IsOK(res1)) {
47063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47064 }
47065 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47066 ecode2 = SWIG_AsVal_int(obj1, &val2);
47067 if (!SWIG_IsOK(ecode2)) {
47068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47069 }
47070 arg2 = static_cast< int >(val2);
47071 {
47072 PyThreadState* __tstate = wxPyBeginAllowThreads();
47073 (arg1)->SetOrientation(arg2);
47074 wxPyEndAllowThreads(__tstate);
47075 if (PyErr_Occurred()) SWIG_fail;
47076 }
47077 resultobj = SWIG_Py_Void();
47078 return resultobj;
47079 fail:
47080 return NULL;
47081 }
47082
47083
47084 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47085 PyObject *obj;
47086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47087 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47088 return SWIG_Py_Void();
47089 }
47090
47091 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47092 return SWIG_Python_InitShadowInstance(args);
47093 }
47094
47095 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47096 PyObject *resultobj = 0;
47097 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47098 int arg2 = (int) wxHORIZONTAL ;
47099 wxStaticBoxSizer *result = 0 ;
47100 void *argp1 = 0 ;
47101 int res1 = 0 ;
47102 int val2 ;
47103 int ecode2 = 0 ;
47104 PyObject * obj0 = 0 ;
47105 PyObject * obj1 = 0 ;
47106 char * kwnames[] = {
47107 (char *) "box",(char *) "orient", NULL
47108 };
47109
47110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47112 if (!SWIG_IsOK(res1)) {
47113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47114 }
47115 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47116 if (obj1) {
47117 ecode2 = SWIG_AsVal_int(obj1, &val2);
47118 if (!SWIG_IsOK(ecode2)) {
47119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47120 }
47121 arg2 = static_cast< int >(val2);
47122 }
47123 {
47124 PyThreadState* __tstate = wxPyBeginAllowThreads();
47125 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47126 wxPyEndAllowThreads(__tstate);
47127 if (PyErr_Occurred()) SWIG_fail;
47128 }
47129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47130 return resultobj;
47131 fail:
47132 return NULL;
47133 }
47134
47135
47136 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47137 PyObject *resultobj = 0;
47138 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47139 wxStaticBox *result = 0 ;
47140 void *argp1 = 0 ;
47141 int res1 = 0 ;
47142 PyObject *swig_obj[1] ;
47143
47144 if (!args) SWIG_fail;
47145 swig_obj[0] = args;
47146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47147 if (!SWIG_IsOK(res1)) {
47148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47149 }
47150 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47151 {
47152 PyThreadState* __tstate = wxPyBeginAllowThreads();
47153 result = (wxStaticBox *)(arg1)->GetStaticBox();
47154 wxPyEndAllowThreads(__tstate);
47155 if (PyErr_Occurred()) SWIG_fail;
47156 }
47157 {
47158 resultobj = wxPyMake_wxObject(result, (bool)0);
47159 }
47160 return resultobj;
47161 fail:
47162 return NULL;
47163 }
47164
47165
47166 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47167 PyObject *obj;
47168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47169 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47170 return SWIG_Py_Void();
47171 }
47172
47173 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47174 return SWIG_Python_InitShadowInstance(args);
47175 }
47176
47177 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47178 PyObject *resultobj = 0;
47179 int arg1 = (int) 1 ;
47180 int arg2 = (int) 0 ;
47181 int arg3 = (int) 0 ;
47182 int arg4 = (int) 0 ;
47183 wxGridSizer *result = 0 ;
47184 int val1 ;
47185 int ecode1 = 0 ;
47186 int val2 ;
47187 int ecode2 = 0 ;
47188 int val3 ;
47189 int ecode3 = 0 ;
47190 int val4 ;
47191 int ecode4 = 0 ;
47192 PyObject * obj0 = 0 ;
47193 PyObject * obj1 = 0 ;
47194 PyObject * obj2 = 0 ;
47195 PyObject * obj3 = 0 ;
47196 char * kwnames[] = {
47197 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47198 };
47199
47200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47201 if (obj0) {
47202 ecode1 = SWIG_AsVal_int(obj0, &val1);
47203 if (!SWIG_IsOK(ecode1)) {
47204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47205 }
47206 arg1 = static_cast< int >(val1);
47207 }
47208 if (obj1) {
47209 ecode2 = SWIG_AsVal_int(obj1, &val2);
47210 if (!SWIG_IsOK(ecode2)) {
47211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47212 }
47213 arg2 = static_cast< int >(val2);
47214 }
47215 if (obj2) {
47216 ecode3 = SWIG_AsVal_int(obj2, &val3);
47217 if (!SWIG_IsOK(ecode3)) {
47218 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47219 }
47220 arg3 = static_cast< int >(val3);
47221 }
47222 if (obj3) {
47223 ecode4 = SWIG_AsVal_int(obj3, &val4);
47224 if (!SWIG_IsOK(ecode4)) {
47225 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47226 }
47227 arg4 = static_cast< int >(val4);
47228 }
47229 {
47230 PyThreadState* __tstate = wxPyBeginAllowThreads();
47231 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47232 wxPyEndAllowThreads(__tstate);
47233 if (PyErr_Occurred()) SWIG_fail;
47234 }
47235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47236 return resultobj;
47237 fail:
47238 return NULL;
47239 }
47240
47241
47242 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47243 PyObject *resultobj = 0;
47244 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47245 int arg2 ;
47246 void *argp1 = 0 ;
47247 int res1 = 0 ;
47248 int val2 ;
47249 int ecode2 = 0 ;
47250 PyObject * obj0 = 0 ;
47251 PyObject * obj1 = 0 ;
47252 char * kwnames[] = {
47253 (char *) "self",(char *) "cols", NULL
47254 };
47255
47256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47258 if (!SWIG_IsOK(res1)) {
47259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47260 }
47261 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47262 ecode2 = SWIG_AsVal_int(obj1, &val2);
47263 if (!SWIG_IsOK(ecode2)) {
47264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47265 }
47266 arg2 = static_cast< int >(val2);
47267 {
47268 PyThreadState* __tstate = wxPyBeginAllowThreads();
47269 (arg1)->SetCols(arg2);
47270 wxPyEndAllowThreads(__tstate);
47271 if (PyErr_Occurred()) SWIG_fail;
47272 }
47273 resultobj = SWIG_Py_Void();
47274 return resultobj;
47275 fail:
47276 return NULL;
47277 }
47278
47279
47280 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47281 PyObject *resultobj = 0;
47282 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47283 int arg2 ;
47284 void *argp1 = 0 ;
47285 int res1 = 0 ;
47286 int val2 ;
47287 int ecode2 = 0 ;
47288 PyObject * obj0 = 0 ;
47289 PyObject * obj1 = 0 ;
47290 char * kwnames[] = {
47291 (char *) "self",(char *) "rows", NULL
47292 };
47293
47294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47296 if (!SWIG_IsOK(res1)) {
47297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47298 }
47299 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47300 ecode2 = SWIG_AsVal_int(obj1, &val2);
47301 if (!SWIG_IsOK(ecode2)) {
47302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47303 }
47304 arg2 = static_cast< int >(val2);
47305 {
47306 PyThreadState* __tstate = wxPyBeginAllowThreads();
47307 (arg1)->SetRows(arg2);
47308 wxPyEndAllowThreads(__tstate);
47309 if (PyErr_Occurred()) SWIG_fail;
47310 }
47311 resultobj = SWIG_Py_Void();
47312 return resultobj;
47313 fail:
47314 return NULL;
47315 }
47316
47317
47318 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47319 PyObject *resultobj = 0;
47320 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47321 int arg2 ;
47322 void *argp1 = 0 ;
47323 int res1 = 0 ;
47324 int val2 ;
47325 int ecode2 = 0 ;
47326 PyObject * obj0 = 0 ;
47327 PyObject * obj1 = 0 ;
47328 char * kwnames[] = {
47329 (char *) "self",(char *) "gap", NULL
47330 };
47331
47332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47334 if (!SWIG_IsOK(res1)) {
47335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47336 }
47337 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47338 ecode2 = SWIG_AsVal_int(obj1, &val2);
47339 if (!SWIG_IsOK(ecode2)) {
47340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47341 }
47342 arg2 = static_cast< int >(val2);
47343 {
47344 PyThreadState* __tstate = wxPyBeginAllowThreads();
47345 (arg1)->SetVGap(arg2);
47346 wxPyEndAllowThreads(__tstate);
47347 if (PyErr_Occurred()) SWIG_fail;
47348 }
47349 resultobj = SWIG_Py_Void();
47350 return resultobj;
47351 fail:
47352 return NULL;
47353 }
47354
47355
47356 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47357 PyObject *resultobj = 0;
47358 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47359 int arg2 ;
47360 void *argp1 = 0 ;
47361 int res1 = 0 ;
47362 int val2 ;
47363 int ecode2 = 0 ;
47364 PyObject * obj0 = 0 ;
47365 PyObject * obj1 = 0 ;
47366 char * kwnames[] = {
47367 (char *) "self",(char *) "gap", NULL
47368 };
47369
47370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47372 if (!SWIG_IsOK(res1)) {
47373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47374 }
47375 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47376 ecode2 = SWIG_AsVal_int(obj1, &val2);
47377 if (!SWIG_IsOK(ecode2)) {
47378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47379 }
47380 arg2 = static_cast< int >(val2);
47381 {
47382 PyThreadState* __tstate = wxPyBeginAllowThreads();
47383 (arg1)->SetHGap(arg2);
47384 wxPyEndAllowThreads(__tstate);
47385 if (PyErr_Occurred()) SWIG_fail;
47386 }
47387 resultobj = SWIG_Py_Void();
47388 return resultobj;
47389 fail:
47390 return NULL;
47391 }
47392
47393
47394 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47395 PyObject *resultobj = 0;
47396 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47397 int result;
47398 void *argp1 = 0 ;
47399 int res1 = 0 ;
47400 PyObject *swig_obj[1] ;
47401
47402 if (!args) SWIG_fail;
47403 swig_obj[0] = args;
47404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47405 if (!SWIG_IsOK(res1)) {
47406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47407 }
47408 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47409 {
47410 PyThreadState* __tstate = wxPyBeginAllowThreads();
47411 result = (int)(arg1)->GetCols();
47412 wxPyEndAllowThreads(__tstate);
47413 if (PyErr_Occurred()) SWIG_fail;
47414 }
47415 resultobj = SWIG_From_int(static_cast< int >(result));
47416 return resultobj;
47417 fail:
47418 return NULL;
47419 }
47420
47421
47422 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47423 PyObject *resultobj = 0;
47424 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47425 int result;
47426 void *argp1 = 0 ;
47427 int res1 = 0 ;
47428 PyObject *swig_obj[1] ;
47429
47430 if (!args) SWIG_fail;
47431 swig_obj[0] = args;
47432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47433 if (!SWIG_IsOK(res1)) {
47434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47435 }
47436 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47437 {
47438 PyThreadState* __tstate = wxPyBeginAllowThreads();
47439 result = (int)(arg1)->GetRows();
47440 wxPyEndAllowThreads(__tstate);
47441 if (PyErr_Occurred()) SWIG_fail;
47442 }
47443 resultobj = SWIG_From_int(static_cast< int >(result));
47444 return resultobj;
47445 fail:
47446 return NULL;
47447 }
47448
47449
47450 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47451 PyObject *resultobj = 0;
47452 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47453 int result;
47454 void *argp1 = 0 ;
47455 int res1 = 0 ;
47456 PyObject *swig_obj[1] ;
47457
47458 if (!args) SWIG_fail;
47459 swig_obj[0] = args;
47460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47461 if (!SWIG_IsOK(res1)) {
47462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47463 }
47464 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47465 {
47466 PyThreadState* __tstate = wxPyBeginAllowThreads();
47467 result = (int)(arg1)->GetVGap();
47468 wxPyEndAllowThreads(__tstate);
47469 if (PyErr_Occurred()) SWIG_fail;
47470 }
47471 resultobj = SWIG_From_int(static_cast< int >(result));
47472 return resultobj;
47473 fail:
47474 return NULL;
47475 }
47476
47477
47478 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47479 PyObject *resultobj = 0;
47480 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47481 int result;
47482 void *argp1 = 0 ;
47483 int res1 = 0 ;
47484 PyObject *swig_obj[1] ;
47485
47486 if (!args) SWIG_fail;
47487 swig_obj[0] = args;
47488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47489 if (!SWIG_IsOK(res1)) {
47490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47491 }
47492 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47493 {
47494 PyThreadState* __tstate = wxPyBeginAllowThreads();
47495 result = (int)(arg1)->GetHGap();
47496 wxPyEndAllowThreads(__tstate);
47497 if (PyErr_Occurred()) SWIG_fail;
47498 }
47499 resultobj = SWIG_From_int(static_cast< int >(result));
47500 return resultobj;
47501 fail:
47502 return NULL;
47503 }
47504
47505
47506 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47507 PyObject *obj;
47508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47509 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47510 return SWIG_Py_Void();
47511 }
47512
47513 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47514 return SWIG_Python_InitShadowInstance(args);
47515 }
47516
47517 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47518 PyObject *resultobj = 0;
47519 int arg1 = (int) 1 ;
47520 int arg2 = (int) 0 ;
47521 int arg3 = (int) 0 ;
47522 int arg4 = (int) 0 ;
47523 wxFlexGridSizer *result = 0 ;
47524 int val1 ;
47525 int ecode1 = 0 ;
47526 int val2 ;
47527 int ecode2 = 0 ;
47528 int val3 ;
47529 int ecode3 = 0 ;
47530 int val4 ;
47531 int ecode4 = 0 ;
47532 PyObject * obj0 = 0 ;
47533 PyObject * obj1 = 0 ;
47534 PyObject * obj2 = 0 ;
47535 PyObject * obj3 = 0 ;
47536 char * kwnames[] = {
47537 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47538 };
47539
47540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47541 if (obj0) {
47542 ecode1 = SWIG_AsVal_int(obj0, &val1);
47543 if (!SWIG_IsOK(ecode1)) {
47544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47545 }
47546 arg1 = static_cast< int >(val1);
47547 }
47548 if (obj1) {
47549 ecode2 = SWIG_AsVal_int(obj1, &val2);
47550 if (!SWIG_IsOK(ecode2)) {
47551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47552 }
47553 arg2 = static_cast< int >(val2);
47554 }
47555 if (obj2) {
47556 ecode3 = SWIG_AsVal_int(obj2, &val3);
47557 if (!SWIG_IsOK(ecode3)) {
47558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47559 }
47560 arg3 = static_cast< int >(val3);
47561 }
47562 if (obj3) {
47563 ecode4 = SWIG_AsVal_int(obj3, &val4);
47564 if (!SWIG_IsOK(ecode4)) {
47565 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47566 }
47567 arg4 = static_cast< int >(val4);
47568 }
47569 {
47570 PyThreadState* __tstate = wxPyBeginAllowThreads();
47571 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47572 wxPyEndAllowThreads(__tstate);
47573 if (PyErr_Occurred()) SWIG_fail;
47574 }
47575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47576 return resultobj;
47577 fail:
47578 return NULL;
47579 }
47580
47581
47582 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47583 PyObject *resultobj = 0;
47584 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47585 size_t arg2 ;
47586 int arg3 = (int) 0 ;
47587 void *argp1 = 0 ;
47588 int res1 = 0 ;
47589 size_t val2 ;
47590 int ecode2 = 0 ;
47591 int val3 ;
47592 int ecode3 = 0 ;
47593 PyObject * obj0 = 0 ;
47594 PyObject * obj1 = 0 ;
47595 PyObject * obj2 = 0 ;
47596 char * kwnames[] = {
47597 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47598 };
47599
47600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47602 if (!SWIG_IsOK(res1)) {
47603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47604 }
47605 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47606 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47607 if (!SWIG_IsOK(ecode2)) {
47608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47609 }
47610 arg2 = static_cast< size_t >(val2);
47611 if (obj2) {
47612 ecode3 = SWIG_AsVal_int(obj2, &val3);
47613 if (!SWIG_IsOK(ecode3)) {
47614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47615 }
47616 arg3 = static_cast< int >(val3);
47617 }
47618 {
47619 PyThreadState* __tstate = wxPyBeginAllowThreads();
47620 (arg1)->AddGrowableRow(arg2,arg3);
47621 wxPyEndAllowThreads(__tstate);
47622 if (PyErr_Occurred()) SWIG_fail;
47623 }
47624 resultobj = SWIG_Py_Void();
47625 return resultobj;
47626 fail:
47627 return NULL;
47628 }
47629
47630
47631 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47632 PyObject *resultobj = 0;
47633 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47634 size_t arg2 ;
47635 void *argp1 = 0 ;
47636 int res1 = 0 ;
47637 size_t val2 ;
47638 int ecode2 = 0 ;
47639 PyObject * obj0 = 0 ;
47640 PyObject * obj1 = 0 ;
47641 char * kwnames[] = {
47642 (char *) "self",(char *) "idx", NULL
47643 };
47644
47645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47647 if (!SWIG_IsOK(res1)) {
47648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47649 }
47650 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47651 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47652 if (!SWIG_IsOK(ecode2)) {
47653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47654 }
47655 arg2 = static_cast< size_t >(val2);
47656 {
47657 PyThreadState* __tstate = wxPyBeginAllowThreads();
47658 (arg1)->RemoveGrowableRow(arg2);
47659 wxPyEndAllowThreads(__tstate);
47660 if (PyErr_Occurred()) SWIG_fail;
47661 }
47662 resultobj = SWIG_Py_Void();
47663 return resultobj;
47664 fail:
47665 return NULL;
47666 }
47667
47668
47669 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47670 PyObject *resultobj = 0;
47671 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47672 size_t arg2 ;
47673 int arg3 = (int) 0 ;
47674 void *argp1 = 0 ;
47675 int res1 = 0 ;
47676 size_t val2 ;
47677 int ecode2 = 0 ;
47678 int val3 ;
47679 int ecode3 = 0 ;
47680 PyObject * obj0 = 0 ;
47681 PyObject * obj1 = 0 ;
47682 PyObject * obj2 = 0 ;
47683 char * kwnames[] = {
47684 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47685 };
47686
47687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47689 if (!SWIG_IsOK(res1)) {
47690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47691 }
47692 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47693 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47694 if (!SWIG_IsOK(ecode2)) {
47695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47696 }
47697 arg2 = static_cast< size_t >(val2);
47698 if (obj2) {
47699 ecode3 = SWIG_AsVal_int(obj2, &val3);
47700 if (!SWIG_IsOK(ecode3)) {
47701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47702 }
47703 arg3 = static_cast< int >(val3);
47704 }
47705 {
47706 PyThreadState* __tstate = wxPyBeginAllowThreads();
47707 (arg1)->AddGrowableCol(arg2,arg3);
47708 wxPyEndAllowThreads(__tstate);
47709 if (PyErr_Occurred()) SWIG_fail;
47710 }
47711 resultobj = SWIG_Py_Void();
47712 return resultobj;
47713 fail:
47714 return NULL;
47715 }
47716
47717
47718 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47719 PyObject *resultobj = 0;
47720 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47721 size_t arg2 ;
47722 void *argp1 = 0 ;
47723 int res1 = 0 ;
47724 size_t val2 ;
47725 int ecode2 = 0 ;
47726 PyObject * obj0 = 0 ;
47727 PyObject * obj1 = 0 ;
47728 char * kwnames[] = {
47729 (char *) "self",(char *) "idx", NULL
47730 };
47731
47732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
47733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47734 if (!SWIG_IsOK(res1)) {
47735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47736 }
47737 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47738 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47739 if (!SWIG_IsOK(ecode2)) {
47740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47741 }
47742 arg2 = static_cast< size_t >(val2);
47743 {
47744 PyThreadState* __tstate = wxPyBeginAllowThreads();
47745 (arg1)->RemoveGrowableCol(arg2);
47746 wxPyEndAllowThreads(__tstate);
47747 if (PyErr_Occurred()) SWIG_fail;
47748 }
47749 resultobj = SWIG_Py_Void();
47750 return resultobj;
47751 fail:
47752 return NULL;
47753 }
47754
47755
47756 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47757 PyObject *resultobj = 0;
47758 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47759 int arg2 ;
47760 void *argp1 = 0 ;
47761 int res1 = 0 ;
47762 int val2 ;
47763 int ecode2 = 0 ;
47764 PyObject * obj0 = 0 ;
47765 PyObject * obj1 = 0 ;
47766 char * kwnames[] = {
47767 (char *) "self",(char *) "direction", NULL
47768 };
47769
47770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
47771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47772 if (!SWIG_IsOK(res1)) {
47773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47774 }
47775 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47776 ecode2 = SWIG_AsVal_int(obj1, &val2);
47777 if (!SWIG_IsOK(ecode2)) {
47778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
47779 }
47780 arg2 = static_cast< int >(val2);
47781 {
47782 PyThreadState* __tstate = wxPyBeginAllowThreads();
47783 (arg1)->SetFlexibleDirection(arg2);
47784 wxPyEndAllowThreads(__tstate);
47785 if (PyErr_Occurred()) SWIG_fail;
47786 }
47787 resultobj = SWIG_Py_Void();
47788 return resultobj;
47789 fail:
47790 return NULL;
47791 }
47792
47793
47794 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47795 PyObject *resultobj = 0;
47796 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47797 int result;
47798 void *argp1 = 0 ;
47799 int res1 = 0 ;
47800 PyObject *swig_obj[1] ;
47801
47802 if (!args) SWIG_fail;
47803 swig_obj[0] = args;
47804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47805 if (!SWIG_IsOK(res1)) {
47806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47807 }
47808 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47809 {
47810 PyThreadState* __tstate = wxPyBeginAllowThreads();
47811 result = (int)(arg1)->GetFlexibleDirection();
47812 wxPyEndAllowThreads(__tstate);
47813 if (PyErr_Occurred()) SWIG_fail;
47814 }
47815 resultobj = SWIG_From_int(static_cast< int >(result));
47816 return resultobj;
47817 fail:
47818 return NULL;
47819 }
47820
47821
47822 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47823 PyObject *resultobj = 0;
47824 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47825 wxFlexSizerGrowMode arg2 ;
47826 void *argp1 = 0 ;
47827 int res1 = 0 ;
47828 int val2 ;
47829 int ecode2 = 0 ;
47830 PyObject * obj0 = 0 ;
47831 PyObject * obj1 = 0 ;
47832 char * kwnames[] = {
47833 (char *) "self",(char *) "mode", NULL
47834 };
47835
47836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
47837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47838 if (!SWIG_IsOK(res1)) {
47839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47840 }
47841 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47842 ecode2 = SWIG_AsVal_int(obj1, &val2);
47843 if (!SWIG_IsOK(ecode2)) {
47844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
47845 }
47846 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
47847 {
47848 PyThreadState* __tstate = wxPyBeginAllowThreads();
47849 (arg1)->SetNonFlexibleGrowMode(arg2);
47850 wxPyEndAllowThreads(__tstate);
47851 if (PyErr_Occurred()) SWIG_fail;
47852 }
47853 resultobj = SWIG_Py_Void();
47854 return resultobj;
47855 fail:
47856 return NULL;
47857 }
47858
47859
47860 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47861 PyObject *resultobj = 0;
47862 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47863 wxFlexSizerGrowMode result;
47864 void *argp1 = 0 ;
47865 int res1 = 0 ;
47866 PyObject *swig_obj[1] ;
47867
47868 if (!args) SWIG_fail;
47869 swig_obj[0] = args;
47870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47871 if (!SWIG_IsOK(res1)) {
47872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47873 }
47874 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47875 {
47876 PyThreadState* __tstate = wxPyBeginAllowThreads();
47877 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
47878 wxPyEndAllowThreads(__tstate);
47879 if (PyErr_Occurred()) SWIG_fail;
47880 }
47881 resultobj = SWIG_From_int(static_cast< int >(result));
47882 return resultobj;
47883 fail:
47884 return NULL;
47885 }
47886
47887
47888 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47889 PyObject *resultobj = 0;
47890 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47891 wxArrayInt *result = 0 ;
47892 void *argp1 = 0 ;
47893 int res1 = 0 ;
47894 PyObject *swig_obj[1] ;
47895
47896 if (!args) SWIG_fail;
47897 swig_obj[0] = args;
47898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47899 if (!SWIG_IsOK(res1)) {
47900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
47901 }
47902 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47903 {
47904 PyThreadState* __tstate = wxPyBeginAllowThreads();
47905 {
47906 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
47907 result = (wxArrayInt *) &_result_ref;
47908 }
47909 wxPyEndAllowThreads(__tstate);
47910 if (PyErr_Occurred()) SWIG_fail;
47911 }
47912 {
47913 resultobj = PyList_New(0);
47914 size_t idx;
47915 for (idx = 0; idx < result->GetCount(); idx += 1) {
47916 PyObject* val = PyInt_FromLong( result->Item(idx) );
47917 PyList_Append(resultobj, val);
47918 Py_DECREF(val);
47919 }
47920 }
47921 return resultobj;
47922 fail:
47923 return NULL;
47924 }
47925
47926
47927 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47928 PyObject *resultobj = 0;
47929 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47930 wxArrayInt *result = 0 ;
47931 void *argp1 = 0 ;
47932 int res1 = 0 ;
47933 PyObject *swig_obj[1] ;
47934
47935 if (!args) SWIG_fail;
47936 swig_obj[0] = args;
47937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47938 if (!SWIG_IsOK(res1)) {
47939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
47940 }
47941 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47942 {
47943 PyThreadState* __tstate = wxPyBeginAllowThreads();
47944 {
47945 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
47946 result = (wxArrayInt *) &_result_ref;
47947 }
47948 wxPyEndAllowThreads(__tstate);
47949 if (PyErr_Occurred()) SWIG_fail;
47950 }
47951 {
47952 resultobj = PyList_New(0);
47953 size_t idx;
47954 for (idx = 0; idx < result->GetCount(); idx += 1) {
47955 PyObject* val = PyInt_FromLong( result->Item(idx) );
47956 PyList_Append(resultobj, val);
47957 Py_DECREF(val);
47958 }
47959 }
47960 return resultobj;
47961 fail:
47962 return NULL;
47963 }
47964
47965
47966 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47967 PyObject *obj;
47968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47969 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
47970 return SWIG_Py_Void();
47971 }
47972
47973 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47974 return SWIG_Python_InitShadowInstance(args);
47975 }
47976
47977 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47978 PyObject *resultobj = 0;
47979 wxStdDialogButtonSizer *result = 0 ;
47980
47981 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
47982 {
47983 PyThreadState* __tstate = wxPyBeginAllowThreads();
47984 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
47985 wxPyEndAllowThreads(__tstate);
47986 if (PyErr_Occurred()) SWIG_fail;
47987 }
47988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
47989 return resultobj;
47990 fail:
47991 return NULL;
47992 }
47993
47994
47995 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47996 PyObject *resultobj = 0;
47997 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
47998 wxButton *arg2 = (wxButton *) 0 ;
47999 void *argp1 = 0 ;
48000 int res1 = 0 ;
48001 void *argp2 = 0 ;
48002 int res2 = 0 ;
48003 PyObject * obj0 = 0 ;
48004 PyObject * obj1 = 0 ;
48005 char * kwnames[] = {
48006 (char *) "self",(char *) "button", NULL
48007 };
48008
48009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48011 if (!SWIG_IsOK(res1)) {
48012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48013 }
48014 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48015 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48016 if (!SWIG_IsOK(res2)) {
48017 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48018 }
48019 arg2 = reinterpret_cast< wxButton * >(argp2);
48020 {
48021 PyThreadState* __tstate = wxPyBeginAllowThreads();
48022 (arg1)->AddButton(arg2);
48023 wxPyEndAllowThreads(__tstate);
48024 if (PyErr_Occurred()) SWIG_fail;
48025 }
48026 resultobj = SWIG_Py_Void();
48027 return resultobj;
48028 fail:
48029 return NULL;
48030 }
48031
48032
48033 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48034 PyObject *resultobj = 0;
48035 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48036 void *argp1 = 0 ;
48037 int res1 = 0 ;
48038 PyObject *swig_obj[1] ;
48039
48040 if (!args) SWIG_fail;
48041 swig_obj[0] = args;
48042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48043 if (!SWIG_IsOK(res1)) {
48044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48045 }
48046 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48047 {
48048 PyThreadState* __tstate = wxPyBeginAllowThreads();
48049 (arg1)->Realize();
48050 wxPyEndAllowThreads(__tstate);
48051 if (PyErr_Occurred()) SWIG_fail;
48052 }
48053 resultobj = SWIG_Py_Void();
48054 return resultobj;
48055 fail:
48056 return NULL;
48057 }
48058
48059
48060 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48061 PyObject *resultobj = 0;
48062 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48063 wxButton *arg2 = (wxButton *) 0 ;
48064 void *argp1 = 0 ;
48065 int res1 = 0 ;
48066 void *argp2 = 0 ;
48067 int res2 = 0 ;
48068 PyObject * obj0 = 0 ;
48069 PyObject * obj1 = 0 ;
48070 char * kwnames[] = {
48071 (char *) "self",(char *) "button", NULL
48072 };
48073
48074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48076 if (!SWIG_IsOK(res1)) {
48077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48078 }
48079 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48080 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48081 if (!SWIG_IsOK(res2)) {
48082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48083 }
48084 arg2 = reinterpret_cast< wxButton * >(argp2);
48085 {
48086 PyThreadState* __tstate = wxPyBeginAllowThreads();
48087 (arg1)->SetAffirmativeButton(arg2);
48088 wxPyEndAllowThreads(__tstate);
48089 if (PyErr_Occurred()) SWIG_fail;
48090 }
48091 resultobj = SWIG_Py_Void();
48092 return resultobj;
48093 fail:
48094 return NULL;
48095 }
48096
48097
48098 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48099 PyObject *resultobj = 0;
48100 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48101 wxButton *arg2 = (wxButton *) 0 ;
48102 void *argp1 = 0 ;
48103 int res1 = 0 ;
48104 void *argp2 = 0 ;
48105 int res2 = 0 ;
48106 PyObject * obj0 = 0 ;
48107 PyObject * obj1 = 0 ;
48108 char * kwnames[] = {
48109 (char *) "self",(char *) "button", NULL
48110 };
48111
48112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48114 if (!SWIG_IsOK(res1)) {
48115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48116 }
48117 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48118 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48119 if (!SWIG_IsOK(res2)) {
48120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48121 }
48122 arg2 = reinterpret_cast< wxButton * >(argp2);
48123 {
48124 PyThreadState* __tstate = wxPyBeginAllowThreads();
48125 (arg1)->SetNegativeButton(arg2);
48126 wxPyEndAllowThreads(__tstate);
48127 if (PyErr_Occurred()) SWIG_fail;
48128 }
48129 resultobj = SWIG_Py_Void();
48130 return resultobj;
48131 fail:
48132 return NULL;
48133 }
48134
48135
48136 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48137 PyObject *resultobj = 0;
48138 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48139 wxButton *arg2 = (wxButton *) 0 ;
48140 void *argp1 = 0 ;
48141 int res1 = 0 ;
48142 void *argp2 = 0 ;
48143 int res2 = 0 ;
48144 PyObject * obj0 = 0 ;
48145 PyObject * obj1 = 0 ;
48146 char * kwnames[] = {
48147 (char *) "self",(char *) "button", NULL
48148 };
48149
48150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48152 if (!SWIG_IsOK(res1)) {
48153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48154 }
48155 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48156 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48157 if (!SWIG_IsOK(res2)) {
48158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48159 }
48160 arg2 = reinterpret_cast< wxButton * >(argp2);
48161 {
48162 PyThreadState* __tstate = wxPyBeginAllowThreads();
48163 (arg1)->SetCancelButton(arg2);
48164 wxPyEndAllowThreads(__tstate);
48165 if (PyErr_Occurred()) SWIG_fail;
48166 }
48167 resultobj = SWIG_Py_Void();
48168 return resultobj;
48169 fail:
48170 return NULL;
48171 }
48172
48173
48174 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48175 PyObject *resultobj = 0;
48176 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48177 wxButton *result = 0 ;
48178 void *argp1 = 0 ;
48179 int res1 = 0 ;
48180 PyObject *swig_obj[1] ;
48181
48182 if (!args) SWIG_fail;
48183 swig_obj[0] = args;
48184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48185 if (!SWIG_IsOK(res1)) {
48186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48187 }
48188 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48189 {
48190 PyThreadState* __tstate = wxPyBeginAllowThreads();
48191 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48192 wxPyEndAllowThreads(__tstate);
48193 if (PyErr_Occurred()) SWIG_fail;
48194 }
48195 {
48196 resultobj = wxPyMake_wxObject(result, (bool)0);
48197 }
48198 return resultobj;
48199 fail:
48200 return NULL;
48201 }
48202
48203
48204 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48205 PyObject *resultobj = 0;
48206 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48207 wxButton *result = 0 ;
48208 void *argp1 = 0 ;
48209 int res1 = 0 ;
48210 PyObject *swig_obj[1] ;
48211
48212 if (!args) SWIG_fail;
48213 swig_obj[0] = args;
48214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48215 if (!SWIG_IsOK(res1)) {
48216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48217 }
48218 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48219 {
48220 PyThreadState* __tstate = wxPyBeginAllowThreads();
48221 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48222 wxPyEndAllowThreads(__tstate);
48223 if (PyErr_Occurred()) SWIG_fail;
48224 }
48225 {
48226 resultobj = wxPyMake_wxObject(result, (bool)0);
48227 }
48228 return resultobj;
48229 fail:
48230 return NULL;
48231 }
48232
48233
48234 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48235 PyObject *resultobj = 0;
48236 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48237 wxButton *result = 0 ;
48238 void *argp1 = 0 ;
48239 int res1 = 0 ;
48240 PyObject *swig_obj[1] ;
48241
48242 if (!args) SWIG_fail;
48243 swig_obj[0] = args;
48244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48245 if (!SWIG_IsOK(res1)) {
48246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48247 }
48248 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48249 {
48250 PyThreadState* __tstate = wxPyBeginAllowThreads();
48251 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48252 wxPyEndAllowThreads(__tstate);
48253 if (PyErr_Occurred()) SWIG_fail;
48254 }
48255 {
48256 resultobj = wxPyMake_wxObject(result, (bool)0);
48257 }
48258 return resultobj;
48259 fail:
48260 return NULL;
48261 }
48262
48263
48264 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48265 PyObject *resultobj = 0;
48266 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48267 wxButton *result = 0 ;
48268 void *argp1 = 0 ;
48269 int res1 = 0 ;
48270 PyObject *swig_obj[1] ;
48271
48272 if (!args) SWIG_fail;
48273 swig_obj[0] = args;
48274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48275 if (!SWIG_IsOK(res1)) {
48276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48277 }
48278 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48279 {
48280 PyThreadState* __tstate = wxPyBeginAllowThreads();
48281 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48282 wxPyEndAllowThreads(__tstate);
48283 if (PyErr_Occurred()) SWIG_fail;
48284 }
48285 {
48286 resultobj = wxPyMake_wxObject(result, (bool)0);
48287 }
48288 return resultobj;
48289 fail:
48290 return NULL;
48291 }
48292
48293
48294 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48295 PyObject *resultobj = 0;
48296 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48297 wxButton *result = 0 ;
48298 void *argp1 = 0 ;
48299 int res1 = 0 ;
48300 PyObject *swig_obj[1] ;
48301
48302 if (!args) SWIG_fail;
48303 swig_obj[0] = args;
48304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48305 if (!SWIG_IsOK(res1)) {
48306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48307 }
48308 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48309 {
48310 PyThreadState* __tstate = wxPyBeginAllowThreads();
48311 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48312 wxPyEndAllowThreads(__tstate);
48313 if (PyErr_Occurred()) SWIG_fail;
48314 }
48315 {
48316 resultobj = wxPyMake_wxObject(result, (bool)0);
48317 }
48318 return resultobj;
48319 fail:
48320 return NULL;
48321 }
48322
48323
48324 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48325 PyObject *obj;
48326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48327 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48328 return SWIG_Py_Void();
48329 }
48330
48331 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48332 return SWIG_Python_InitShadowInstance(args);
48333 }
48334
48335 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48336 PyObject *resultobj = 0;
48337 int arg1 = (int) 0 ;
48338 int arg2 = (int) 0 ;
48339 wxGBPosition *result = 0 ;
48340 int val1 ;
48341 int ecode1 = 0 ;
48342 int val2 ;
48343 int ecode2 = 0 ;
48344 PyObject * obj0 = 0 ;
48345 PyObject * obj1 = 0 ;
48346 char * kwnames[] = {
48347 (char *) "row",(char *) "col", NULL
48348 };
48349
48350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48351 if (obj0) {
48352 ecode1 = SWIG_AsVal_int(obj0, &val1);
48353 if (!SWIG_IsOK(ecode1)) {
48354 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48355 }
48356 arg1 = static_cast< int >(val1);
48357 }
48358 if (obj1) {
48359 ecode2 = SWIG_AsVal_int(obj1, &val2);
48360 if (!SWIG_IsOK(ecode2)) {
48361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48362 }
48363 arg2 = static_cast< int >(val2);
48364 }
48365 {
48366 PyThreadState* __tstate = wxPyBeginAllowThreads();
48367 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48368 wxPyEndAllowThreads(__tstate);
48369 if (PyErr_Occurred()) SWIG_fail;
48370 }
48371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48372 return resultobj;
48373 fail:
48374 return NULL;
48375 }
48376
48377
48378 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48379 PyObject *resultobj = 0;
48380 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48381 void *argp1 = 0 ;
48382 int res1 = 0 ;
48383 PyObject *swig_obj[1] ;
48384
48385 if (!args) SWIG_fail;
48386 swig_obj[0] = args;
48387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48388 if (!SWIG_IsOK(res1)) {
48389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48390 }
48391 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48392 {
48393 PyThreadState* __tstate = wxPyBeginAllowThreads();
48394 delete arg1;
48395
48396 wxPyEndAllowThreads(__tstate);
48397 if (PyErr_Occurred()) SWIG_fail;
48398 }
48399 resultobj = SWIG_Py_Void();
48400 return resultobj;
48401 fail:
48402 return NULL;
48403 }
48404
48405
48406 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48407 PyObject *resultobj = 0;
48408 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48409 int result;
48410 void *argp1 = 0 ;
48411 int res1 = 0 ;
48412 PyObject *swig_obj[1] ;
48413
48414 if (!args) SWIG_fail;
48415 swig_obj[0] = args;
48416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48417 if (!SWIG_IsOK(res1)) {
48418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48419 }
48420 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48421 {
48422 PyThreadState* __tstate = wxPyBeginAllowThreads();
48423 result = (int)((wxGBPosition const *)arg1)->GetRow();
48424 wxPyEndAllowThreads(__tstate);
48425 if (PyErr_Occurred()) SWIG_fail;
48426 }
48427 resultobj = SWIG_From_int(static_cast< int >(result));
48428 return resultobj;
48429 fail:
48430 return NULL;
48431 }
48432
48433
48434 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48435 PyObject *resultobj = 0;
48436 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48437 int result;
48438 void *argp1 = 0 ;
48439 int res1 = 0 ;
48440 PyObject *swig_obj[1] ;
48441
48442 if (!args) SWIG_fail;
48443 swig_obj[0] = args;
48444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48445 if (!SWIG_IsOK(res1)) {
48446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48447 }
48448 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48449 {
48450 PyThreadState* __tstate = wxPyBeginAllowThreads();
48451 result = (int)((wxGBPosition const *)arg1)->GetCol();
48452 wxPyEndAllowThreads(__tstate);
48453 if (PyErr_Occurred()) SWIG_fail;
48454 }
48455 resultobj = SWIG_From_int(static_cast< int >(result));
48456 return resultobj;
48457 fail:
48458 return NULL;
48459 }
48460
48461
48462 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48463 PyObject *resultobj = 0;
48464 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48465 int arg2 ;
48466 void *argp1 = 0 ;
48467 int res1 = 0 ;
48468 int val2 ;
48469 int ecode2 = 0 ;
48470 PyObject * obj0 = 0 ;
48471 PyObject * obj1 = 0 ;
48472 char * kwnames[] = {
48473 (char *) "self",(char *) "row", NULL
48474 };
48475
48476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48478 if (!SWIG_IsOK(res1)) {
48479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48480 }
48481 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48482 ecode2 = SWIG_AsVal_int(obj1, &val2);
48483 if (!SWIG_IsOK(ecode2)) {
48484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48485 }
48486 arg2 = static_cast< int >(val2);
48487 {
48488 PyThreadState* __tstate = wxPyBeginAllowThreads();
48489 (arg1)->SetRow(arg2);
48490 wxPyEndAllowThreads(__tstate);
48491 if (PyErr_Occurred()) SWIG_fail;
48492 }
48493 resultobj = SWIG_Py_Void();
48494 return resultobj;
48495 fail:
48496 return NULL;
48497 }
48498
48499
48500 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48501 PyObject *resultobj = 0;
48502 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48503 int arg2 ;
48504 void *argp1 = 0 ;
48505 int res1 = 0 ;
48506 int val2 ;
48507 int ecode2 = 0 ;
48508 PyObject * obj0 = 0 ;
48509 PyObject * obj1 = 0 ;
48510 char * kwnames[] = {
48511 (char *) "self",(char *) "col", NULL
48512 };
48513
48514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48516 if (!SWIG_IsOK(res1)) {
48517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48518 }
48519 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48520 ecode2 = SWIG_AsVal_int(obj1, &val2);
48521 if (!SWIG_IsOK(ecode2)) {
48522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48523 }
48524 arg2 = static_cast< int >(val2);
48525 {
48526 PyThreadState* __tstate = wxPyBeginAllowThreads();
48527 (arg1)->SetCol(arg2);
48528 wxPyEndAllowThreads(__tstate);
48529 if (PyErr_Occurred()) SWIG_fail;
48530 }
48531 resultobj = SWIG_Py_Void();
48532 return resultobj;
48533 fail:
48534 return NULL;
48535 }
48536
48537
48538 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48539 PyObject *resultobj = 0;
48540 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48541 wxGBPosition *arg2 = 0 ;
48542 bool result;
48543 void *argp1 = 0 ;
48544 int res1 = 0 ;
48545 wxGBPosition temp2 ;
48546 PyObject * obj0 = 0 ;
48547 PyObject * obj1 = 0 ;
48548 char * kwnames[] = {
48549 (char *) "self",(char *) "other", NULL
48550 };
48551
48552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48554 if (!SWIG_IsOK(res1)) {
48555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48556 }
48557 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48558 {
48559 arg2 = &temp2;
48560 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48561 }
48562 {
48563 PyThreadState* __tstate = wxPyBeginAllowThreads();
48564 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
48565 wxPyEndAllowThreads(__tstate);
48566 if (PyErr_Occurred()) SWIG_fail;
48567 }
48568 {
48569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48570 }
48571 return resultobj;
48572 fail:
48573 return NULL;
48574 }
48575
48576
48577 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48578 PyObject *resultobj = 0;
48579 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48580 wxGBPosition *arg2 = 0 ;
48581 bool result;
48582 void *argp1 = 0 ;
48583 int res1 = 0 ;
48584 wxGBPosition temp2 ;
48585 PyObject * obj0 = 0 ;
48586 PyObject * obj1 = 0 ;
48587 char * kwnames[] = {
48588 (char *) "self",(char *) "other", NULL
48589 };
48590
48591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48593 if (!SWIG_IsOK(res1)) {
48594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48595 }
48596 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48597 {
48598 arg2 = &temp2;
48599 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48600 }
48601 {
48602 PyThreadState* __tstate = wxPyBeginAllowThreads();
48603 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
48604 wxPyEndAllowThreads(__tstate);
48605 if (PyErr_Occurred()) SWIG_fail;
48606 }
48607 {
48608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48609 }
48610 return resultobj;
48611 fail:
48612 return NULL;
48613 }
48614
48615
48616 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48617 PyObject *resultobj = 0;
48618 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48619 int arg2 = (int) 0 ;
48620 int arg3 = (int) 0 ;
48621 void *argp1 = 0 ;
48622 int res1 = 0 ;
48623 int val2 ;
48624 int ecode2 = 0 ;
48625 int val3 ;
48626 int ecode3 = 0 ;
48627 PyObject * obj0 = 0 ;
48628 PyObject * obj1 = 0 ;
48629 PyObject * obj2 = 0 ;
48630 char * kwnames[] = {
48631 (char *) "self",(char *) "row",(char *) "col", NULL
48632 };
48633
48634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48636 if (!SWIG_IsOK(res1)) {
48637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48638 }
48639 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48640 if (obj1) {
48641 ecode2 = SWIG_AsVal_int(obj1, &val2);
48642 if (!SWIG_IsOK(ecode2)) {
48643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48644 }
48645 arg2 = static_cast< int >(val2);
48646 }
48647 if (obj2) {
48648 ecode3 = SWIG_AsVal_int(obj2, &val3);
48649 if (!SWIG_IsOK(ecode3)) {
48650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48651 }
48652 arg3 = static_cast< int >(val3);
48653 }
48654 {
48655 PyThreadState* __tstate = wxPyBeginAllowThreads();
48656 wxGBPosition_Set(arg1,arg2,arg3);
48657 wxPyEndAllowThreads(__tstate);
48658 if (PyErr_Occurred()) SWIG_fail;
48659 }
48660 resultobj = SWIG_Py_Void();
48661 return resultobj;
48662 fail:
48663 return NULL;
48664 }
48665
48666
48667 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48668 PyObject *resultobj = 0;
48669 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48670 PyObject *result = 0 ;
48671 void *argp1 = 0 ;
48672 int res1 = 0 ;
48673 PyObject *swig_obj[1] ;
48674
48675 if (!args) SWIG_fail;
48676 swig_obj[0] = args;
48677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48678 if (!SWIG_IsOK(res1)) {
48679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48680 }
48681 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48682 {
48683 PyThreadState* __tstate = wxPyBeginAllowThreads();
48684 result = (PyObject *)wxGBPosition_Get(arg1);
48685 wxPyEndAllowThreads(__tstate);
48686 if (PyErr_Occurred()) SWIG_fail;
48687 }
48688 resultobj = result;
48689 return resultobj;
48690 fail:
48691 return NULL;
48692 }
48693
48694
48695 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48696 PyObject *obj;
48697 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48698 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48699 return SWIG_Py_Void();
48700 }
48701
48702 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48703 return SWIG_Python_InitShadowInstance(args);
48704 }
48705
48706 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48707 PyObject *resultobj = 0;
48708 int arg1 = (int) 1 ;
48709 int arg2 = (int) 1 ;
48710 wxGBSpan *result = 0 ;
48711 int val1 ;
48712 int ecode1 = 0 ;
48713 int val2 ;
48714 int ecode2 = 0 ;
48715 PyObject * obj0 = 0 ;
48716 PyObject * obj1 = 0 ;
48717 char * kwnames[] = {
48718 (char *) "rowspan",(char *) "colspan", NULL
48719 };
48720
48721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48722 if (obj0) {
48723 ecode1 = SWIG_AsVal_int(obj0, &val1);
48724 if (!SWIG_IsOK(ecode1)) {
48725 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48726 }
48727 arg1 = static_cast< int >(val1);
48728 }
48729 if (obj1) {
48730 ecode2 = SWIG_AsVal_int(obj1, &val2);
48731 if (!SWIG_IsOK(ecode2)) {
48732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48733 }
48734 arg2 = static_cast< int >(val2);
48735 }
48736 {
48737 PyThreadState* __tstate = wxPyBeginAllowThreads();
48738 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48739 wxPyEndAllowThreads(__tstate);
48740 if (PyErr_Occurred()) SWIG_fail;
48741 }
48742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
48743 return resultobj;
48744 fail:
48745 return NULL;
48746 }
48747
48748
48749 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48750 PyObject *resultobj = 0;
48751 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48752 void *argp1 = 0 ;
48753 int res1 = 0 ;
48754 PyObject *swig_obj[1] ;
48755
48756 if (!args) SWIG_fail;
48757 swig_obj[0] = args;
48758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
48759 if (!SWIG_IsOK(res1)) {
48760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48761 }
48762 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48763 {
48764 PyThreadState* __tstate = wxPyBeginAllowThreads();
48765 delete arg1;
48766
48767 wxPyEndAllowThreads(__tstate);
48768 if (PyErr_Occurred()) SWIG_fail;
48769 }
48770 resultobj = SWIG_Py_Void();
48771 return resultobj;
48772 fail:
48773 return NULL;
48774 }
48775
48776
48777 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48778 PyObject *resultobj = 0;
48779 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48780 int result;
48781 void *argp1 = 0 ;
48782 int res1 = 0 ;
48783 PyObject *swig_obj[1] ;
48784
48785 if (!args) SWIG_fail;
48786 swig_obj[0] = args;
48787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48788 if (!SWIG_IsOK(res1)) {
48789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48790 }
48791 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48792 {
48793 PyThreadState* __tstate = wxPyBeginAllowThreads();
48794 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
48795 wxPyEndAllowThreads(__tstate);
48796 if (PyErr_Occurred()) SWIG_fail;
48797 }
48798 resultobj = SWIG_From_int(static_cast< int >(result));
48799 return resultobj;
48800 fail:
48801 return NULL;
48802 }
48803
48804
48805 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48806 PyObject *resultobj = 0;
48807 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48808 int result;
48809 void *argp1 = 0 ;
48810 int res1 = 0 ;
48811 PyObject *swig_obj[1] ;
48812
48813 if (!args) SWIG_fail;
48814 swig_obj[0] = args;
48815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48816 if (!SWIG_IsOK(res1)) {
48817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48818 }
48819 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48820 {
48821 PyThreadState* __tstate = wxPyBeginAllowThreads();
48822 result = (int)((wxGBSpan const *)arg1)->GetColspan();
48823 wxPyEndAllowThreads(__tstate);
48824 if (PyErr_Occurred()) SWIG_fail;
48825 }
48826 resultobj = SWIG_From_int(static_cast< int >(result));
48827 return resultobj;
48828 fail:
48829 return NULL;
48830 }
48831
48832
48833 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48834 PyObject *resultobj = 0;
48835 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48836 int arg2 ;
48837 void *argp1 = 0 ;
48838 int res1 = 0 ;
48839 int val2 ;
48840 int ecode2 = 0 ;
48841 PyObject * obj0 = 0 ;
48842 PyObject * obj1 = 0 ;
48843 char * kwnames[] = {
48844 (char *) "self",(char *) "rowspan", NULL
48845 };
48846
48847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
48848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48849 if (!SWIG_IsOK(res1)) {
48850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48851 }
48852 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48853 ecode2 = SWIG_AsVal_int(obj1, &val2);
48854 if (!SWIG_IsOK(ecode2)) {
48855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
48856 }
48857 arg2 = static_cast< int >(val2);
48858 {
48859 PyThreadState* __tstate = wxPyBeginAllowThreads();
48860 (arg1)->SetRowspan(arg2);
48861 wxPyEndAllowThreads(__tstate);
48862 if (PyErr_Occurred()) SWIG_fail;
48863 }
48864 resultobj = SWIG_Py_Void();
48865 return resultobj;
48866 fail:
48867 return NULL;
48868 }
48869
48870
48871 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48872 PyObject *resultobj = 0;
48873 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48874 int arg2 ;
48875 void *argp1 = 0 ;
48876 int res1 = 0 ;
48877 int val2 ;
48878 int ecode2 = 0 ;
48879 PyObject * obj0 = 0 ;
48880 PyObject * obj1 = 0 ;
48881 char * kwnames[] = {
48882 (char *) "self",(char *) "colspan", NULL
48883 };
48884
48885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
48886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48887 if (!SWIG_IsOK(res1)) {
48888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48889 }
48890 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48891 ecode2 = SWIG_AsVal_int(obj1, &val2);
48892 if (!SWIG_IsOK(ecode2)) {
48893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
48894 }
48895 arg2 = static_cast< int >(val2);
48896 {
48897 PyThreadState* __tstate = wxPyBeginAllowThreads();
48898 (arg1)->SetColspan(arg2);
48899 wxPyEndAllowThreads(__tstate);
48900 if (PyErr_Occurred()) SWIG_fail;
48901 }
48902 resultobj = SWIG_Py_Void();
48903 return resultobj;
48904 fail:
48905 return NULL;
48906 }
48907
48908
48909 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48910 PyObject *resultobj = 0;
48911 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48912 wxGBSpan *arg2 = 0 ;
48913 bool result;
48914 void *argp1 = 0 ;
48915 int res1 = 0 ;
48916 wxGBSpan temp2 ;
48917 PyObject * obj0 = 0 ;
48918 PyObject * obj1 = 0 ;
48919 char * kwnames[] = {
48920 (char *) "self",(char *) "other", NULL
48921 };
48922
48923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48925 if (!SWIG_IsOK(res1)) {
48926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48927 }
48928 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48929 {
48930 arg2 = &temp2;
48931 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
48932 }
48933 {
48934 PyThreadState* __tstate = wxPyBeginAllowThreads();
48935 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
48936 wxPyEndAllowThreads(__tstate);
48937 if (PyErr_Occurred()) SWIG_fail;
48938 }
48939 {
48940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48941 }
48942 return resultobj;
48943 fail:
48944 return NULL;
48945 }
48946
48947
48948 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48949 PyObject *resultobj = 0;
48950 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48951 wxGBSpan *arg2 = 0 ;
48952 bool result;
48953 void *argp1 = 0 ;
48954 int res1 = 0 ;
48955 wxGBSpan temp2 ;
48956 PyObject * obj0 = 0 ;
48957 PyObject * obj1 = 0 ;
48958 char * kwnames[] = {
48959 (char *) "self",(char *) "other", NULL
48960 };
48961
48962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48964 if (!SWIG_IsOK(res1)) {
48965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48966 }
48967 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48968 {
48969 arg2 = &temp2;
48970 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
48971 }
48972 {
48973 PyThreadState* __tstate = wxPyBeginAllowThreads();
48974 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
48975 wxPyEndAllowThreads(__tstate);
48976 if (PyErr_Occurred()) SWIG_fail;
48977 }
48978 {
48979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48980 }
48981 return resultobj;
48982 fail:
48983 return NULL;
48984 }
48985
48986
48987 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48988 PyObject *resultobj = 0;
48989 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48990 int arg2 = (int) 1 ;
48991 int arg3 = (int) 1 ;
48992 void *argp1 = 0 ;
48993 int res1 = 0 ;
48994 int val2 ;
48995 int ecode2 = 0 ;
48996 int val3 ;
48997 int ecode3 = 0 ;
48998 PyObject * obj0 = 0 ;
48999 PyObject * obj1 = 0 ;
49000 PyObject * obj2 = 0 ;
49001 char * kwnames[] = {
49002 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49003 };
49004
49005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49007 if (!SWIG_IsOK(res1)) {
49008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49009 }
49010 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49011 if (obj1) {
49012 ecode2 = SWIG_AsVal_int(obj1, &val2);
49013 if (!SWIG_IsOK(ecode2)) {
49014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49015 }
49016 arg2 = static_cast< int >(val2);
49017 }
49018 if (obj2) {
49019 ecode3 = SWIG_AsVal_int(obj2, &val3);
49020 if (!SWIG_IsOK(ecode3)) {
49021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49022 }
49023 arg3 = static_cast< int >(val3);
49024 }
49025 {
49026 PyThreadState* __tstate = wxPyBeginAllowThreads();
49027 wxGBSpan_Set(arg1,arg2,arg3);
49028 wxPyEndAllowThreads(__tstate);
49029 if (PyErr_Occurred()) SWIG_fail;
49030 }
49031 resultobj = SWIG_Py_Void();
49032 return resultobj;
49033 fail:
49034 return NULL;
49035 }
49036
49037
49038 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49039 PyObject *resultobj = 0;
49040 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49041 PyObject *result = 0 ;
49042 void *argp1 = 0 ;
49043 int res1 = 0 ;
49044 PyObject *swig_obj[1] ;
49045
49046 if (!args) SWIG_fail;
49047 swig_obj[0] = args;
49048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49049 if (!SWIG_IsOK(res1)) {
49050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49051 }
49052 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49053 {
49054 PyThreadState* __tstate = wxPyBeginAllowThreads();
49055 result = (PyObject *)wxGBSpan_Get(arg1);
49056 wxPyEndAllowThreads(__tstate);
49057 if (PyErr_Occurred()) SWIG_fail;
49058 }
49059 resultobj = result;
49060 return resultobj;
49061 fail:
49062 return NULL;
49063 }
49064
49065
49066 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49067 PyObject *obj;
49068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49069 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49070 return SWIG_Py_Void();
49071 }
49072
49073 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49074 return SWIG_Python_InitShadowInstance(args);
49075 }
49076
49077 SWIGINTERN int DefaultSpan_set(PyObject *) {
49078 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49079 return 1;
49080 }
49081
49082
49083 SWIGINTERN PyObject *DefaultSpan_get(void) {
49084 PyObject *pyobj = 0;
49085
49086 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49087 return pyobj;
49088 }
49089
49090
49091 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49092 PyObject *resultobj = 0;
49093 wxGBSizerItem *result = 0 ;
49094
49095 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49096 {
49097 PyThreadState* __tstate = wxPyBeginAllowThreads();
49098 result = (wxGBSizerItem *)new wxGBSizerItem();
49099 wxPyEndAllowThreads(__tstate);
49100 if (PyErr_Occurred()) SWIG_fail;
49101 }
49102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49103 return resultobj;
49104 fail:
49105 return NULL;
49106 }
49107
49108
49109 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49110 PyObject *resultobj = 0;
49111 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49112 void *argp1 = 0 ;
49113 int res1 = 0 ;
49114 PyObject *swig_obj[1] ;
49115
49116 if (!args) SWIG_fail;
49117 swig_obj[0] = args;
49118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49119 if (!SWIG_IsOK(res1)) {
49120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49121 }
49122 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49123 {
49124 PyThreadState* __tstate = wxPyBeginAllowThreads();
49125 delete arg1;
49126
49127 wxPyEndAllowThreads(__tstate);
49128 if (PyErr_Occurred()) SWIG_fail;
49129 }
49130 resultobj = SWIG_Py_Void();
49131 return resultobj;
49132 fail:
49133 return NULL;
49134 }
49135
49136
49137 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49138 PyObject *resultobj = 0;
49139 wxWindow *arg1 = (wxWindow *) 0 ;
49140 wxGBPosition *arg2 = 0 ;
49141 wxGBSpan *arg3 = 0 ;
49142 int arg4 ;
49143 int arg5 ;
49144 PyObject *arg6 = (PyObject *) NULL ;
49145 wxGBSizerItem *result = 0 ;
49146 void *argp1 = 0 ;
49147 int res1 = 0 ;
49148 wxGBPosition temp2 ;
49149 wxGBSpan temp3 ;
49150 int val4 ;
49151 int ecode4 = 0 ;
49152 int val5 ;
49153 int ecode5 = 0 ;
49154 PyObject * obj0 = 0 ;
49155 PyObject * obj1 = 0 ;
49156 PyObject * obj2 = 0 ;
49157 PyObject * obj3 = 0 ;
49158 PyObject * obj4 = 0 ;
49159 PyObject * obj5 = 0 ;
49160 char * kwnames[] = {
49161 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49162 };
49163
49164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49166 if (!SWIG_IsOK(res1)) {
49167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49168 }
49169 arg1 = reinterpret_cast< wxWindow * >(argp1);
49170 {
49171 arg2 = &temp2;
49172 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49173 }
49174 {
49175 arg3 = &temp3;
49176 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49177 }
49178 ecode4 = SWIG_AsVal_int(obj3, &val4);
49179 if (!SWIG_IsOK(ecode4)) {
49180 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49181 }
49182 arg4 = static_cast< int >(val4);
49183 ecode5 = SWIG_AsVal_int(obj4, &val5);
49184 if (!SWIG_IsOK(ecode5)) {
49185 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49186 }
49187 arg5 = static_cast< int >(val5);
49188 if (obj5) {
49189 arg6 = obj5;
49190 }
49191 {
49192 PyThreadState* __tstate = wxPyBeginAllowThreads();
49193 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49194 wxPyEndAllowThreads(__tstate);
49195 if (PyErr_Occurred()) SWIG_fail;
49196 }
49197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49198 return resultobj;
49199 fail:
49200 return NULL;
49201 }
49202
49203
49204 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49205 PyObject *resultobj = 0;
49206 wxSizer *arg1 = (wxSizer *) 0 ;
49207 wxGBPosition *arg2 = 0 ;
49208 wxGBSpan *arg3 = 0 ;
49209 int arg4 ;
49210 int arg5 ;
49211 PyObject *arg6 = (PyObject *) NULL ;
49212 wxGBSizerItem *result = 0 ;
49213 int res1 = 0 ;
49214 wxGBPosition temp2 ;
49215 wxGBSpan temp3 ;
49216 int val4 ;
49217 int ecode4 = 0 ;
49218 int val5 ;
49219 int ecode5 = 0 ;
49220 PyObject * obj0 = 0 ;
49221 PyObject * obj1 = 0 ;
49222 PyObject * obj2 = 0 ;
49223 PyObject * obj3 = 0 ;
49224 PyObject * obj4 = 0 ;
49225 PyObject * obj5 = 0 ;
49226 char * kwnames[] = {
49227 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49228 };
49229
49230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49231 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49232 if (!SWIG_IsOK(res1)) {
49233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49234 }
49235 {
49236 arg2 = &temp2;
49237 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49238 }
49239 {
49240 arg3 = &temp3;
49241 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49242 }
49243 ecode4 = SWIG_AsVal_int(obj3, &val4);
49244 if (!SWIG_IsOK(ecode4)) {
49245 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49246 }
49247 arg4 = static_cast< int >(val4);
49248 ecode5 = SWIG_AsVal_int(obj4, &val5);
49249 if (!SWIG_IsOK(ecode5)) {
49250 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49251 }
49252 arg5 = static_cast< int >(val5);
49253 if (obj5) {
49254 arg6 = obj5;
49255 }
49256 {
49257 PyThreadState* __tstate = wxPyBeginAllowThreads();
49258 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49259 wxPyEndAllowThreads(__tstate);
49260 if (PyErr_Occurred()) SWIG_fail;
49261 }
49262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49263 return resultobj;
49264 fail:
49265 return NULL;
49266 }
49267
49268
49269 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49270 PyObject *resultobj = 0;
49271 int arg1 ;
49272 int arg2 ;
49273 wxGBPosition *arg3 = 0 ;
49274 wxGBSpan *arg4 = 0 ;
49275 int arg5 ;
49276 int arg6 ;
49277 PyObject *arg7 = (PyObject *) NULL ;
49278 wxGBSizerItem *result = 0 ;
49279 int val1 ;
49280 int ecode1 = 0 ;
49281 int val2 ;
49282 int ecode2 = 0 ;
49283 wxGBPosition temp3 ;
49284 wxGBSpan temp4 ;
49285 int val5 ;
49286 int ecode5 = 0 ;
49287 int val6 ;
49288 int ecode6 = 0 ;
49289 PyObject * obj0 = 0 ;
49290 PyObject * obj1 = 0 ;
49291 PyObject * obj2 = 0 ;
49292 PyObject * obj3 = 0 ;
49293 PyObject * obj4 = 0 ;
49294 PyObject * obj5 = 0 ;
49295 PyObject * obj6 = 0 ;
49296 char * kwnames[] = {
49297 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49298 };
49299
49300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49301 ecode1 = SWIG_AsVal_int(obj0, &val1);
49302 if (!SWIG_IsOK(ecode1)) {
49303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49304 }
49305 arg1 = static_cast< int >(val1);
49306 ecode2 = SWIG_AsVal_int(obj1, &val2);
49307 if (!SWIG_IsOK(ecode2)) {
49308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49309 }
49310 arg2 = static_cast< int >(val2);
49311 {
49312 arg3 = &temp3;
49313 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49314 }
49315 {
49316 arg4 = &temp4;
49317 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49318 }
49319 ecode5 = SWIG_AsVal_int(obj4, &val5);
49320 if (!SWIG_IsOK(ecode5)) {
49321 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49322 }
49323 arg5 = static_cast< int >(val5);
49324 ecode6 = SWIG_AsVal_int(obj5, &val6);
49325 if (!SWIG_IsOK(ecode6)) {
49326 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49327 }
49328 arg6 = static_cast< int >(val6);
49329 if (obj6) {
49330 arg7 = obj6;
49331 }
49332 {
49333 PyThreadState* __tstate = wxPyBeginAllowThreads();
49334 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49335 wxPyEndAllowThreads(__tstate);
49336 if (PyErr_Occurred()) SWIG_fail;
49337 }
49338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49339 return resultobj;
49340 fail:
49341 return NULL;
49342 }
49343
49344
49345 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49346 PyObject *resultobj = 0;
49347 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49348 wxGBPosition result;
49349 void *argp1 = 0 ;
49350 int res1 = 0 ;
49351 PyObject *swig_obj[1] ;
49352
49353 if (!args) SWIG_fail;
49354 swig_obj[0] = args;
49355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49356 if (!SWIG_IsOK(res1)) {
49357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49358 }
49359 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49360 {
49361 PyThreadState* __tstate = wxPyBeginAllowThreads();
49362 result = ((wxGBSizerItem const *)arg1)->GetPos();
49363 wxPyEndAllowThreads(__tstate);
49364 if (PyErr_Occurred()) SWIG_fail;
49365 }
49366 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49367 return resultobj;
49368 fail:
49369 return NULL;
49370 }
49371
49372
49373 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49374 PyObject *resultobj = 0;
49375 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49376 wxGBSpan result;
49377 void *argp1 = 0 ;
49378 int res1 = 0 ;
49379 PyObject *swig_obj[1] ;
49380
49381 if (!args) SWIG_fail;
49382 swig_obj[0] = args;
49383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49384 if (!SWIG_IsOK(res1)) {
49385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49386 }
49387 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49388 {
49389 PyThreadState* __tstate = wxPyBeginAllowThreads();
49390 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49391 wxPyEndAllowThreads(__tstate);
49392 if (PyErr_Occurred()) SWIG_fail;
49393 }
49394 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49395 return resultobj;
49396 fail:
49397 return NULL;
49398 }
49399
49400
49401 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49402 PyObject *resultobj = 0;
49403 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49404 wxGBPosition *arg2 = 0 ;
49405 bool result;
49406 void *argp1 = 0 ;
49407 int res1 = 0 ;
49408 wxGBPosition temp2 ;
49409 PyObject * obj0 = 0 ;
49410 PyObject * obj1 = 0 ;
49411 char * kwnames[] = {
49412 (char *) "self",(char *) "pos", NULL
49413 };
49414
49415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49417 if (!SWIG_IsOK(res1)) {
49418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49419 }
49420 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49421 {
49422 arg2 = &temp2;
49423 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49424 }
49425 {
49426 PyThreadState* __tstate = wxPyBeginAllowThreads();
49427 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49428 wxPyEndAllowThreads(__tstate);
49429 if (PyErr_Occurred()) SWIG_fail;
49430 }
49431 {
49432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49433 }
49434 return resultobj;
49435 fail:
49436 return NULL;
49437 }
49438
49439
49440 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49441 PyObject *resultobj = 0;
49442 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49443 wxGBSpan *arg2 = 0 ;
49444 bool result;
49445 void *argp1 = 0 ;
49446 int res1 = 0 ;
49447 wxGBSpan temp2 ;
49448 PyObject * obj0 = 0 ;
49449 PyObject * obj1 = 0 ;
49450 char * kwnames[] = {
49451 (char *) "self",(char *) "span", NULL
49452 };
49453
49454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49456 if (!SWIG_IsOK(res1)) {
49457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49458 }
49459 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49460 {
49461 arg2 = &temp2;
49462 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49463 }
49464 {
49465 PyThreadState* __tstate = wxPyBeginAllowThreads();
49466 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49467 wxPyEndAllowThreads(__tstate);
49468 if (PyErr_Occurred()) SWIG_fail;
49469 }
49470 {
49471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49472 }
49473 return resultobj;
49474 fail:
49475 return NULL;
49476 }
49477
49478
49479 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49480 PyObject *resultobj = 0;
49481 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49482 wxGBSizerItem *arg2 = 0 ;
49483 bool result;
49484 void *argp1 = 0 ;
49485 int res1 = 0 ;
49486 void *argp2 = 0 ;
49487 int res2 = 0 ;
49488 PyObject * obj0 = 0 ;
49489 PyObject * obj1 = 0 ;
49490 char * kwnames[] = {
49491 (char *) "self",(char *) "other", NULL
49492 };
49493
49494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49496 if (!SWIG_IsOK(res1)) {
49497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49498 }
49499 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49500 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49501 if (!SWIG_IsOK(res2)) {
49502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49503 }
49504 if (!argp2) {
49505 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49506 }
49507 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49508 {
49509 PyThreadState* __tstate = wxPyBeginAllowThreads();
49510 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49511 wxPyEndAllowThreads(__tstate);
49512 if (PyErr_Occurred()) SWIG_fail;
49513 }
49514 {
49515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49516 }
49517 return resultobj;
49518 fail:
49519 return NULL;
49520 }
49521
49522
49523 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49524 PyObject *resultobj = 0;
49525 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49526 wxGBPosition *arg2 = 0 ;
49527 wxGBSpan *arg3 = 0 ;
49528 bool result;
49529 void *argp1 = 0 ;
49530 int res1 = 0 ;
49531 wxGBPosition temp2 ;
49532 wxGBSpan temp3 ;
49533 PyObject * obj0 = 0 ;
49534 PyObject * obj1 = 0 ;
49535 PyObject * obj2 = 0 ;
49536 char * kwnames[] = {
49537 (char *) "self",(char *) "pos",(char *) "span", NULL
49538 };
49539
49540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49542 if (!SWIG_IsOK(res1)) {
49543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49544 }
49545 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49546 {
49547 arg2 = &temp2;
49548 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49549 }
49550 {
49551 arg3 = &temp3;
49552 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49553 }
49554 {
49555 PyThreadState* __tstate = wxPyBeginAllowThreads();
49556 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49557 wxPyEndAllowThreads(__tstate);
49558 if (PyErr_Occurred()) SWIG_fail;
49559 }
49560 {
49561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49562 }
49563 return resultobj;
49564 fail:
49565 return NULL;
49566 }
49567
49568
49569 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49570 PyObject *resultobj = 0;
49571 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49572 wxGBPosition result;
49573 void *argp1 = 0 ;
49574 int res1 = 0 ;
49575 PyObject *swig_obj[1] ;
49576
49577 if (!args) SWIG_fail;
49578 swig_obj[0] = args;
49579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49580 if (!SWIG_IsOK(res1)) {
49581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49582 }
49583 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49584 {
49585 PyThreadState* __tstate = wxPyBeginAllowThreads();
49586 result = wxGBSizerItem_GetEndPos(arg1);
49587 wxPyEndAllowThreads(__tstate);
49588 if (PyErr_Occurred()) SWIG_fail;
49589 }
49590 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49591 return resultobj;
49592 fail:
49593 return NULL;
49594 }
49595
49596
49597 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49598 PyObject *resultobj = 0;
49599 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49600 wxGridBagSizer *result = 0 ;
49601 void *argp1 = 0 ;
49602 int res1 = 0 ;
49603 PyObject *swig_obj[1] ;
49604
49605 if (!args) SWIG_fail;
49606 swig_obj[0] = args;
49607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49608 if (!SWIG_IsOK(res1)) {
49609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49610 }
49611 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49612 {
49613 PyThreadState* __tstate = wxPyBeginAllowThreads();
49614 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49615 wxPyEndAllowThreads(__tstate);
49616 if (PyErr_Occurred()) SWIG_fail;
49617 }
49618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49619 return resultobj;
49620 fail:
49621 return NULL;
49622 }
49623
49624
49625 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49626 PyObject *resultobj = 0;
49627 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49628 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49629 void *argp1 = 0 ;
49630 int res1 = 0 ;
49631 void *argp2 = 0 ;
49632 int res2 = 0 ;
49633 PyObject * obj0 = 0 ;
49634 PyObject * obj1 = 0 ;
49635 char * kwnames[] = {
49636 (char *) "self",(char *) "sizer", NULL
49637 };
49638
49639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49641 if (!SWIG_IsOK(res1)) {
49642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49643 }
49644 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49645 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49646 if (!SWIG_IsOK(res2)) {
49647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49648 }
49649 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49650 {
49651 PyThreadState* __tstate = wxPyBeginAllowThreads();
49652 (arg1)->SetGBSizer(arg2);
49653 wxPyEndAllowThreads(__tstate);
49654 if (PyErr_Occurred()) SWIG_fail;
49655 }
49656 resultobj = SWIG_Py_Void();
49657 return resultobj;
49658 fail:
49659 return NULL;
49660 }
49661
49662
49663 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49664 PyObject *obj;
49665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49666 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49667 return SWIG_Py_Void();
49668 }
49669
49670 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49671 return SWIG_Python_InitShadowInstance(args);
49672 }
49673
49674 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49675 PyObject *resultobj = 0;
49676 int arg1 = (int) 0 ;
49677 int arg2 = (int) 0 ;
49678 wxGridBagSizer *result = 0 ;
49679 int val1 ;
49680 int ecode1 = 0 ;
49681 int val2 ;
49682 int ecode2 = 0 ;
49683 PyObject * obj0 = 0 ;
49684 PyObject * obj1 = 0 ;
49685 char * kwnames[] = {
49686 (char *) "vgap",(char *) "hgap", NULL
49687 };
49688
49689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49690 if (obj0) {
49691 ecode1 = SWIG_AsVal_int(obj0, &val1);
49692 if (!SWIG_IsOK(ecode1)) {
49693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49694 }
49695 arg1 = static_cast< int >(val1);
49696 }
49697 if (obj1) {
49698 ecode2 = SWIG_AsVal_int(obj1, &val2);
49699 if (!SWIG_IsOK(ecode2)) {
49700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49701 }
49702 arg2 = static_cast< int >(val2);
49703 }
49704 {
49705 PyThreadState* __tstate = wxPyBeginAllowThreads();
49706 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49707 wxPyEndAllowThreads(__tstate);
49708 if (PyErr_Occurred()) SWIG_fail;
49709 }
49710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49711 return resultobj;
49712 fail:
49713 return NULL;
49714 }
49715
49716
49717 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49718 PyObject *resultobj = 0;
49719 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49720 PyObject *arg2 = (PyObject *) 0 ;
49721 wxGBPosition *arg3 = 0 ;
49722 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49723 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49724 int arg5 = (int) 0 ;
49725 int arg6 = (int) 0 ;
49726 PyObject *arg7 = (PyObject *) NULL ;
49727 wxGBSizerItem *result = 0 ;
49728 void *argp1 = 0 ;
49729 int res1 = 0 ;
49730 wxGBPosition temp3 ;
49731 wxGBSpan temp4 ;
49732 int val5 ;
49733 int ecode5 = 0 ;
49734 int val6 ;
49735 int ecode6 = 0 ;
49736 PyObject * obj0 = 0 ;
49737 PyObject * obj1 = 0 ;
49738 PyObject * obj2 = 0 ;
49739 PyObject * obj3 = 0 ;
49740 PyObject * obj4 = 0 ;
49741 PyObject * obj5 = 0 ;
49742 PyObject * obj6 = 0 ;
49743 char * kwnames[] = {
49744 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49745 };
49746
49747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49749 if (!SWIG_IsOK(res1)) {
49750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49751 }
49752 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49753 arg2 = obj1;
49754 {
49755 arg3 = &temp3;
49756 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49757 }
49758 if (obj3) {
49759 {
49760 arg4 = &temp4;
49761 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49762 }
49763 }
49764 if (obj4) {
49765 ecode5 = SWIG_AsVal_int(obj4, &val5);
49766 if (!SWIG_IsOK(ecode5)) {
49767 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
49768 }
49769 arg5 = static_cast< int >(val5);
49770 }
49771 if (obj5) {
49772 ecode6 = SWIG_AsVal_int(obj5, &val6);
49773 if (!SWIG_IsOK(ecode6)) {
49774 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
49775 }
49776 arg6 = static_cast< int >(val6);
49777 }
49778 if (obj6) {
49779 arg7 = obj6;
49780 }
49781 {
49782 PyThreadState* __tstate = wxPyBeginAllowThreads();
49783 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49784 wxPyEndAllowThreads(__tstate);
49785 if (PyErr_Occurred()) SWIG_fail;
49786 }
49787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49788 return resultobj;
49789 fail:
49790 return NULL;
49791 }
49792
49793
49794 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49795 PyObject *resultobj = 0;
49796 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49797 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
49798 wxGBSizerItem *result = 0 ;
49799 void *argp1 = 0 ;
49800 int res1 = 0 ;
49801 int res2 = 0 ;
49802 PyObject * obj0 = 0 ;
49803 PyObject * obj1 = 0 ;
49804 char * kwnames[] = {
49805 (char *) "self",(char *) "item", NULL
49806 };
49807
49808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
49809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49810 if (!SWIG_IsOK(res1)) {
49811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49812 }
49813 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49814 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49815 if (!SWIG_IsOK(res2)) {
49816 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
49817 }
49818 {
49819 PyThreadState* __tstate = wxPyBeginAllowThreads();
49820 result = (wxGBSizerItem *)(arg1)->Add(arg2);
49821 wxPyEndAllowThreads(__tstate);
49822 if (PyErr_Occurred()) SWIG_fail;
49823 }
49824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49825 return resultobj;
49826 fail:
49827 return NULL;
49828 }
49829
49830
49831 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49832 PyObject *resultobj = 0;
49833 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49834 int arg2 ;
49835 int arg3 ;
49836 wxSize result;
49837 void *argp1 = 0 ;
49838 int res1 = 0 ;
49839 int val2 ;
49840 int ecode2 = 0 ;
49841 int val3 ;
49842 int ecode3 = 0 ;
49843 PyObject * obj0 = 0 ;
49844 PyObject * obj1 = 0 ;
49845 PyObject * obj2 = 0 ;
49846 char * kwnames[] = {
49847 (char *) "self",(char *) "row",(char *) "col", NULL
49848 };
49849
49850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49852 if (!SWIG_IsOK(res1)) {
49853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
49854 }
49855 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49856 ecode2 = SWIG_AsVal_int(obj1, &val2);
49857 if (!SWIG_IsOK(ecode2)) {
49858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
49859 }
49860 arg2 = static_cast< int >(val2);
49861 ecode3 = SWIG_AsVal_int(obj2, &val3);
49862 if (!SWIG_IsOK(ecode3)) {
49863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
49864 }
49865 arg3 = static_cast< int >(val3);
49866 {
49867 PyThreadState* __tstate = wxPyBeginAllowThreads();
49868 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
49869 wxPyEndAllowThreads(__tstate);
49870 if (PyErr_Occurred()) SWIG_fail;
49871 }
49872 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49873 return resultobj;
49874 fail:
49875 return NULL;
49876 }
49877
49878
49879 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49880 PyObject *resultobj = 0;
49881 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49882 wxSize result;
49883 void *argp1 = 0 ;
49884 int res1 = 0 ;
49885 PyObject *swig_obj[1] ;
49886
49887 if (!args) SWIG_fail;
49888 swig_obj[0] = args;
49889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49890 if (!SWIG_IsOK(res1)) {
49891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
49892 }
49893 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49894 {
49895 PyThreadState* __tstate = wxPyBeginAllowThreads();
49896 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
49897 wxPyEndAllowThreads(__tstate);
49898 if (PyErr_Occurred()) SWIG_fail;
49899 }
49900 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49901 return resultobj;
49902 fail:
49903 return NULL;
49904 }
49905
49906
49907 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49908 PyObject *resultobj = 0;
49909 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49910 wxSize *arg2 = 0 ;
49911 void *argp1 = 0 ;
49912 int res1 = 0 ;
49913 wxSize temp2 ;
49914 PyObject * obj0 = 0 ;
49915 PyObject * obj1 = 0 ;
49916 char * kwnames[] = {
49917 (char *) "self",(char *) "sz", NULL
49918 };
49919
49920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
49921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49922 if (!SWIG_IsOK(res1)) {
49923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49924 }
49925 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49926 {
49927 arg2 = &temp2;
49928 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49929 }
49930 {
49931 PyThreadState* __tstate = wxPyBeginAllowThreads();
49932 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
49933 wxPyEndAllowThreads(__tstate);
49934 if (PyErr_Occurred()) SWIG_fail;
49935 }
49936 resultobj = SWIG_Py_Void();
49937 return resultobj;
49938 fail:
49939 return NULL;
49940 }
49941
49942
49943 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
49944 PyObject *resultobj = 0;
49945 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49946 wxWindow *arg2 = (wxWindow *) 0 ;
49947 wxGBPosition result;
49948 void *argp1 = 0 ;
49949 int res1 = 0 ;
49950 void *argp2 = 0 ;
49951 int res2 = 0 ;
49952
49953 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
49954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49955 if (!SWIG_IsOK(res1)) {
49956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49957 }
49958 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49959 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49960 if (!SWIG_IsOK(res2)) {
49961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
49962 }
49963 arg2 = reinterpret_cast< wxWindow * >(argp2);
49964 {
49965 PyThreadState* __tstate = wxPyBeginAllowThreads();
49966 result = (arg1)->GetItemPosition(arg2);
49967 wxPyEndAllowThreads(__tstate);
49968 if (PyErr_Occurred()) SWIG_fail;
49969 }
49970 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49971 return resultobj;
49972 fail:
49973 return NULL;
49974 }
49975
49976
49977 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
49978 PyObject *resultobj = 0;
49979 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49980 wxSizer *arg2 = (wxSizer *) 0 ;
49981 wxGBPosition result;
49982 void *argp1 = 0 ;
49983 int res1 = 0 ;
49984 void *argp2 = 0 ;
49985 int res2 = 0 ;
49986
49987 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
49988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49989 if (!SWIG_IsOK(res1)) {
49990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49991 }
49992 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49993 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
49994 if (!SWIG_IsOK(res2)) {
49995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
49996 }
49997 arg2 = reinterpret_cast< wxSizer * >(argp2);
49998 {
49999 PyThreadState* __tstate = wxPyBeginAllowThreads();
50000 result = (arg1)->GetItemPosition(arg2);
50001 wxPyEndAllowThreads(__tstate);
50002 if (PyErr_Occurred()) SWIG_fail;
50003 }
50004 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50005 return resultobj;
50006 fail:
50007 return NULL;
50008 }
50009
50010
50011 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50012 PyObject *resultobj = 0;
50013 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50014 size_t arg2 ;
50015 wxGBPosition result;
50016 void *argp1 = 0 ;
50017 int res1 = 0 ;
50018 size_t val2 ;
50019 int ecode2 = 0 ;
50020
50021 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50023 if (!SWIG_IsOK(res1)) {
50024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50025 }
50026 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50027 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50028 if (!SWIG_IsOK(ecode2)) {
50029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50030 }
50031 arg2 = static_cast< size_t >(val2);
50032 {
50033 PyThreadState* __tstate = wxPyBeginAllowThreads();
50034 result = (arg1)->GetItemPosition(arg2);
50035 wxPyEndAllowThreads(__tstate);
50036 if (PyErr_Occurred()) SWIG_fail;
50037 }
50038 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50039 return resultobj;
50040 fail:
50041 return NULL;
50042 }
50043
50044
50045 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50046 int argc;
50047 PyObject *argv[3];
50048
50049 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50050 --argc;
50051 if (argc == 2) {
50052 int _v = 0;
50053 {
50054 void *vptr = 0;
50055 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50056 _v = SWIG_CheckState(res);
50057 }
50058 if (!_v) goto check_1;
50059 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50060 }
50061 check_1:
50062
50063 if (argc == 2) {
50064 int _v = 0;
50065 {
50066 void *vptr = 0;
50067 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50068 _v = SWIG_CheckState(res);
50069 }
50070 if (!_v) goto check_2;
50071 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50072 }
50073 check_2:
50074
50075 if (argc == 2) {
50076 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50077 }
50078
50079 fail:
50080 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50081 return NULL;
50082 }
50083
50084
50085 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50086 PyObject *resultobj = 0;
50087 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50088 wxWindow *arg2 = (wxWindow *) 0 ;
50089 wxGBPosition *arg3 = 0 ;
50090 bool result;
50091 void *argp1 = 0 ;
50092 int res1 = 0 ;
50093 void *argp2 = 0 ;
50094 int res2 = 0 ;
50095 wxGBPosition temp3 ;
50096
50097 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50099 if (!SWIG_IsOK(res1)) {
50100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50101 }
50102 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50103 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50104 if (!SWIG_IsOK(res2)) {
50105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50106 }
50107 arg2 = reinterpret_cast< wxWindow * >(argp2);
50108 {
50109 arg3 = &temp3;
50110 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50111 }
50112 {
50113 PyThreadState* __tstate = wxPyBeginAllowThreads();
50114 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50115 wxPyEndAllowThreads(__tstate);
50116 if (PyErr_Occurred()) SWIG_fail;
50117 }
50118 {
50119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50120 }
50121 return resultobj;
50122 fail:
50123 return NULL;
50124 }
50125
50126
50127 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50128 PyObject *resultobj = 0;
50129 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50130 wxSizer *arg2 = (wxSizer *) 0 ;
50131 wxGBPosition *arg3 = 0 ;
50132 bool result;
50133 void *argp1 = 0 ;
50134 int res1 = 0 ;
50135 void *argp2 = 0 ;
50136 int res2 = 0 ;
50137 wxGBPosition temp3 ;
50138
50139 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50141 if (!SWIG_IsOK(res1)) {
50142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50143 }
50144 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50145 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50146 if (!SWIG_IsOK(res2)) {
50147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50148 }
50149 arg2 = reinterpret_cast< wxSizer * >(argp2);
50150 {
50151 arg3 = &temp3;
50152 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50153 }
50154 {
50155 PyThreadState* __tstate = wxPyBeginAllowThreads();
50156 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50157 wxPyEndAllowThreads(__tstate);
50158 if (PyErr_Occurred()) SWIG_fail;
50159 }
50160 {
50161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50162 }
50163 return resultobj;
50164 fail:
50165 return NULL;
50166 }
50167
50168
50169 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50170 PyObject *resultobj = 0;
50171 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50172 size_t arg2 ;
50173 wxGBPosition *arg3 = 0 ;
50174 bool result;
50175 void *argp1 = 0 ;
50176 int res1 = 0 ;
50177 size_t val2 ;
50178 int ecode2 = 0 ;
50179 wxGBPosition temp3 ;
50180
50181 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50183 if (!SWIG_IsOK(res1)) {
50184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50185 }
50186 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50187 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50188 if (!SWIG_IsOK(ecode2)) {
50189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50190 }
50191 arg2 = static_cast< size_t >(val2);
50192 {
50193 arg3 = &temp3;
50194 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50195 }
50196 {
50197 PyThreadState* __tstate = wxPyBeginAllowThreads();
50198 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50199 wxPyEndAllowThreads(__tstate);
50200 if (PyErr_Occurred()) SWIG_fail;
50201 }
50202 {
50203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50204 }
50205 return resultobj;
50206 fail:
50207 return NULL;
50208 }
50209
50210
50211 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50212 int argc;
50213 PyObject *argv[4];
50214
50215 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50216 --argc;
50217 if (argc == 3) {
50218 int _v = 0;
50219 {
50220 void *vptr = 0;
50221 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50222 _v = SWIG_CheckState(res);
50223 }
50224 if (!_v) goto check_1;
50225 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50226 }
50227 check_1:
50228
50229 if (argc == 3) {
50230 int _v = 0;
50231 {
50232 void *vptr = 0;
50233 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50234 _v = SWIG_CheckState(res);
50235 }
50236 if (!_v) goto check_2;
50237 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50238 }
50239 check_2:
50240
50241 if (argc == 3) {
50242 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50243 }
50244
50245 fail:
50246 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50247 return NULL;
50248 }
50249
50250
50251 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50252 PyObject *resultobj = 0;
50253 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50254 wxWindow *arg2 = (wxWindow *) 0 ;
50255 wxGBSpan result;
50256 void *argp1 = 0 ;
50257 int res1 = 0 ;
50258 void *argp2 = 0 ;
50259 int res2 = 0 ;
50260
50261 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50263 if (!SWIG_IsOK(res1)) {
50264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50265 }
50266 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50267 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50268 if (!SWIG_IsOK(res2)) {
50269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50270 }
50271 arg2 = reinterpret_cast< wxWindow * >(argp2);
50272 {
50273 PyThreadState* __tstate = wxPyBeginAllowThreads();
50274 result = (arg1)->GetItemSpan(arg2);
50275 wxPyEndAllowThreads(__tstate);
50276 if (PyErr_Occurred()) SWIG_fail;
50277 }
50278 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50279 return resultobj;
50280 fail:
50281 return NULL;
50282 }
50283
50284
50285 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50286 PyObject *resultobj = 0;
50287 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50288 wxSizer *arg2 = (wxSizer *) 0 ;
50289 wxGBSpan result;
50290 void *argp1 = 0 ;
50291 int res1 = 0 ;
50292 void *argp2 = 0 ;
50293 int res2 = 0 ;
50294
50295 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50297 if (!SWIG_IsOK(res1)) {
50298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50299 }
50300 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50301 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50302 if (!SWIG_IsOK(res2)) {
50303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50304 }
50305 arg2 = reinterpret_cast< wxSizer * >(argp2);
50306 {
50307 PyThreadState* __tstate = wxPyBeginAllowThreads();
50308 result = (arg1)->GetItemSpan(arg2);
50309 wxPyEndAllowThreads(__tstate);
50310 if (PyErr_Occurred()) SWIG_fail;
50311 }
50312 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50313 return resultobj;
50314 fail:
50315 return NULL;
50316 }
50317
50318
50319 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50320 PyObject *resultobj = 0;
50321 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50322 size_t arg2 ;
50323 wxGBSpan result;
50324 void *argp1 = 0 ;
50325 int res1 = 0 ;
50326 size_t val2 ;
50327 int ecode2 = 0 ;
50328
50329 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50331 if (!SWIG_IsOK(res1)) {
50332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50333 }
50334 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50335 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50336 if (!SWIG_IsOK(ecode2)) {
50337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50338 }
50339 arg2 = static_cast< size_t >(val2);
50340 {
50341 PyThreadState* __tstate = wxPyBeginAllowThreads();
50342 result = (arg1)->GetItemSpan(arg2);
50343 wxPyEndAllowThreads(__tstate);
50344 if (PyErr_Occurred()) SWIG_fail;
50345 }
50346 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50347 return resultobj;
50348 fail:
50349 return NULL;
50350 }
50351
50352
50353 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50354 int argc;
50355 PyObject *argv[3];
50356
50357 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50358 --argc;
50359 if (argc == 2) {
50360 int _v = 0;
50361 {
50362 void *vptr = 0;
50363 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50364 _v = SWIG_CheckState(res);
50365 }
50366 if (!_v) goto check_1;
50367 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50368 }
50369 check_1:
50370
50371 if (argc == 2) {
50372 int _v = 0;
50373 {
50374 void *vptr = 0;
50375 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50376 _v = SWIG_CheckState(res);
50377 }
50378 if (!_v) goto check_2;
50379 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50380 }
50381 check_2:
50382
50383 if (argc == 2) {
50384 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50385 }
50386
50387 fail:
50388 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50389 return NULL;
50390 }
50391
50392
50393 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50394 PyObject *resultobj = 0;
50395 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50396 wxWindow *arg2 = (wxWindow *) 0 ;
50397 wxGBSpan *arg3 = 0 ;
50398 bool result;
50399 void *argp1 = 0 ;
50400 int res1 = 0 ;
50401 void *argp2 = 0 ;
50402 int res2 = 0 ;
50403 wxGBSpan temp3 ;
50404
50405 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50407 if (!SWIG_IsOK(res1)) {
50408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50409 }
50410 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50411 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50412 if (!SWIG_IsOK(res2)) {
50413 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50414 }
50415 arg2 = reinterpret_cast< wxWindow * >(argp2);
50416 {
50417 arg3 = &temp3;
50418 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50419 }
50420 {
50421 PyThreadState* __tstate = wxPyBeginAllowThreads();
50422 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50423 wxPyEndAllowThreads(__tstate);
50424 if (PyErr_Occurred()) SWIG_fail;
50425 }
50426 {
50427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50428 }
50429 return resultobj;
50430 fail:
50431 return NULL;
50432 }
50433
50434
50435 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50436 PyObject *resultobj = 0;
50437 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50438 wxSizer *arg2 = (wxSizer *) 0 ;
50439 wxGBSpan *arg3 = 0 ;
50440 bool result;
50441 void *argp1 = 0 ;
50442 int res1 = 0 ;
50443 void *argp2 = 0 ;
50444 int res2 = 0 ;
50445 wxGBSpan temp3 ;
50446
50447 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50449 if (!SWIG_IsOK(res1)) {
50450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50451 }
50452 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50453 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50454 if (!SWIG_IsOK(res2)) {
50455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50456 }
50457 arg2 = reinterpret_cast< wxSizer * >(argp2);
50458 {
50459 arg3 = &temp3;
50460 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50461 }
50462 {
50463 PyThreadState* __tstate = wxPyBeginAllowThreads();
50464 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50465 wxPyEndAllowThreads(__tstate);
50466 if (PyErr_Occurred()) SWIG_fail;
50467 }
50468 {
50469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50470 }
50471 return resultobj;
50472 fail:
50473 return NULL;
50474 }
50475
50476
50477 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50478 PyObject *resultobj = 0;
50479 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50480 size_t arg2 ;
50481 wxGBSpan *arg3 = 0 ;
50482 bool result;
50483 void *argp1 = 0 ;
50484 int res1 = 0 ;
50485 size_t val2 ;
50486 int ecode2 = 0 ;
50487 wxGBSpan temp3 ;
50488
50489 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50491 if (!SWIG_IsOK(res1)) {
50492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50493 }
50494 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50495 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50496 if (!SWIG_IsOK(ecode2)) {
50497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50498 }
50499 arg2 = static_cast< size_t >(val2);
50500 {
50501 arg3 = &temp3;
50502 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50503 }
50504 {
50505 PyThreadState* __tstate = wxPyBeginAllowThreads();
50506 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50507 wxPyEndAllowThreads(__tstate);
50508 if (PyErr_Occurred()) SWIG_fail;
50509 }
50510 {
50511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50512 }
50513 return resultobj;
50514 fail:
50515 return NULL;
50516 }
50517
50518
50519 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50520 int argc;
50521 PyObject *argv[4];
50522
50523 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50524 --argc;
50525 if (argc == 3) {
50526 int _v = 0;
50527 {
50528 void *vptr = 0;
50529 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50530 _v = SWIG_CheckState(res);
50531 }
50532 if (!_v) goto check_1;
50533 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50534 }
50535 check_1:
50536
50537 if (argc == 3) {
50538 int _v = 0;
50539 {
50540 void *vptr = 0;
50541 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50542 _v = SWIG_CheckState(res);
50543 }
50544 if (!_v) goto check_2;
50545 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50546 }
50547 check_2:
50548
50549 if (argc == 3) {
50550 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50551 }
50552
50553 fail:
50554 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50555 return NULL;
50556 }
50557
50558
50559 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50560 PyObject *resultobj = 0;
50561 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50562 wxWindow *arg2 = (wxWindow *) 0 ;
50563 wxGBSizerItem *result = 0 ;
50564 void *argp1 = 0 ;
50565 int res1 = 0 ;
50566 void *argp2 = 0 ;
50567 int res2 = 0 ;
50568
50569 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50571 if (!SWIG_IsOK(res1)) {
50572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50573 }
50574 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50575 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50576 if (!SWIG_IsOK(res2)) {
50577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50578 }
50579 arg2 = reinterpret_cast< wxWindow * >(argp2);
50580 {
50581 PyThreadState* __tstate = wxPyBeginAllowThreads();
50582 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50583 wxPyEndAllowThreads(__tstate);
50584 if (PyErr_Occurred()) SWIG_fail;
50585 }
50586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50587 return resultobj;
50588 fail:
50589 return NULL;
50590 }
50591
50592
50593 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50594 PyObject *resultobj = 0;
50595 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50596 wxSizer *arg2 = (wxSizer *) 0 ;
50597 wxGBSizerItem *result = 0 ;
50598 void *argp1 = 0 ;
50599 int res1 = 0 ;
50600 void *argp2 = 0 ;
50601 int res2 = 0 ;
50602
50603 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50605 if (!SWIG_IsOK(res1)) {
50606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50607 }
50608 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50609 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50610 if (!SWIG_IsOK(res2)) {
50611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50612 }
50613 arg2 = reinterpret_cast< wxSizer * >(argp2);
50614 {
50615 PyThreadState* __tstate = wxPyBeginAllowThreads();
50616 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50617 wxPyEndAllowThreads(__tstate);
50618 if (PyErr_Occurred()) SWIG_fail;
50619 }
50620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50621 return resultobj;
50622 fail:
50623 return NULL;
50624 }
50625
50626
50627 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50628 int argc;
50629 PyObject *argv[3];
50630
50631 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50632 --argc;
50633 if (argc == 2) {
50634 int _v = 0;
50635 {
50636 void *vptr = 0;
50637 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50638 _v = SWIG_CheckState(res);
50639 }
50640 if (!_v) goto check_1;
50641 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50642 }
50643 check_1:
50644
50645 if (argc == 2) {
50646 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50647 }
50648
50649 fail:
50650 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50651 return NULL;
50652 }
50653
50654
50655 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50656 PyObject *resultobj = 0;
50657 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50658 wxGBPosition *arg2 = 0 ;
50659 wxGBSizerItem *result = 0 ;
50660 void *argp1 = 0 ;
50661 int res1 = 0 ;
50662 wxGBPosition temp2 ;
50663 PyObject * obj0 = 0 ;
50664 PyObject * obj1 = 0 ;
50665 char * kwnames[] = {
50666 (char *) "self",(char *) "pos", NULL
50667 };
50668
50669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50671 if (!SWIG_IsOK(res1)) {
50672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50673 }
50674 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50675 {
50676 arg2 = &temp2;
50677 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50678 }
50679 {
50680 PyThreadState* __tstate = wxPyBeginAllowThreads();
50681 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50682 wxPyEndAllowThreads(__tstate);
50683 if (PyErr_Occurred()) SWIG_fail;
50684 }
50685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50686 return resultobj;
50687 fail:
50688 return NULL;
50689 }
50690
50691
50692 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50693 PyObject *resultobj = 0;
50694 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50695 wxPoint *arg2 = 0 ;
50696 wxGBSizerItem *result = 0 ;
50697 void *argp1 = 0 ;
50698 int res1 = 0 ;
50699 wxPoint temp2 ;
50700 PyObject * obj0 = 0 ;
50701 PyObject * obj1 = 0 ;
50702 char * kwnames[] = {
50703 (char *) "self",(char *) "pt", NULL
50704 };
50705
50706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50708 if (!SWIG_IsOK(res1)) {
50709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50710 }
50711 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50712 {
50713 arg2 = &temp2;
50714 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50715 }
50716 {
50717 PyThreadState* __tstate = wxPyBeginAllowThreads();
50718 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50719 wxPyEndAllowThreads(__tstate);
50720 if (PyErr_Occurred()) SWIG_fail;
50721 }
50722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50723 return resultobj;
50724 fail:
50725 return NULL;
50726 }
50727
50728
50729 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50730 PyObject *resultobj = 0;
50731 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50732 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50733 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50734 bool result;
50735 void *argp1 = 0 ;
50736 int res1 = 0 ;
50737 void *argp2 = 0 ;
50738 int res2 = 0 ;
50739 void *argp3 = 0 ;
50740 int res3 = 0 ;
50741 PyObject * obj0 = 0 ;
50742 PyObject * obj1 = 0 ;
50743 PyObject * obj2 = 0 ;
50744 char * kwnames[] = {
50745 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50746 };
50747
50748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50750 if (!SWIG_IsOK(res1)) {
50751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50752 }
50753 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50754 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50755 if (!SWIG_IsOK(res2)) {
50756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50757 }
50758 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50759 if (obj2) {
50760 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50761 if (!SWIG_IsOK(res3)) {
50762 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
50763 }
50764 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
50765 }
50766 {
50767 PyThreadState* __tstate = wxPyBeginAllowThreads();
50768 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
50769 wxPyEndAllowThreads(__tstate);
50770 if (PyErr_Occurred()) SWIG_fail;
50771 }
50772 {
50773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50774 }
50775 return resultobj;
50776 fail:
50777 return NULL;
50778 }
50779
50780
50781 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50782 PyObject *resultobj = 0;
50783 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50784 wxGBPosition *arg2 = 0 ;
50785 wxGBSpan *arg3 = 0 ;
50786 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
50787 bool result;
50788 void *argp1 = 0 ;
50789 int res1 = 0 ;
50790 wxGBPosition temp2 ;
50791 wxGBSpan temp3 ;
50792 void *argp4 = 0 ;
50793 int res4 = 0 ;
50794 PyObject * obj0 = 0 ;
50795 PyObject * obj1 = 0 ;
50796 PyObject * obj2 = 0 ;
50797 PyObject * obj3 = 0 ;
50798 char * kwnames[] = {
50799 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
50800 };
50801
50802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50804 if (!SWIG_IsOK(res1)) {
50805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50806 }
50807 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50808 {
50809 arg2 = &temp2;
50810 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50811 }
50812 {
50813 arg3 = &temp3;
50814 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50815 }
50816 if (obj3) {
50817 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50818 if (!SWIG_IsOK(res4)) {
50819 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
50820 }
50821 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
50822 }
50823 {
50824 PyThreadState* __tstate = wxPyBeginAllowThreads();
50825 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
50826 wxPyEndAllowThreads(__tstate);
50827 if (PyErr_Occurred()) SWIG_fail;
50828 }
50829 {
50830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50831 }
50832 return resultobj;
50833 fail:
50834 return NULL;
50835 }
50836
50837
50838 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50839 PyObject *obj;
50840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50841 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
50842 return SWIG_Py_Void();
50843 }
50844
50845 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50846 return SWIG_Python_InitShadowInstance(args);
50847 }
50848
50849 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50850 PyObject *resultobj = 0;
50851 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
50852 wxRelationship arg2 ;
50853 wxWindow *arg3 = (wxWindow *) 0 ;
50854 wxEdge arg4 ;
50855 int arg5 = (int) 0 ;
50856 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
50857 void *argp1 = 0 ;
50858 int res1 = 0 ;
50859 int val2 ;
50860 int ecode2 = 0 ;
50861 void *argp3 = 0 ;
50862 int res3 = 0 ;
50863 int val4 ;
50864 int ecode4 = 0 ;
50865 int val5 ;
50866 int ecode5 = 0 ;
50867 int val6 ;
50868 int ecode6 = 0 ;
50869 PyObject * obj0 = 0 ;
50870 PyObject * obj1 = 0 ;
50871 PyObject * obj2 = 0 ;
50872 PyObject * obj3 = 0 ;
50873 PyObject * obj4 = 0 ;
50874 PyObject * obj5 = 0 ;
50875 char * kwnames[] = {
50876 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
50877 };
50878
50879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
50881 if (!SWIG_IsOK(res1)) {
50882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
50883 }
50884 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
50885 ecode2 = SWIG_AsVal_int(obj1, &val2);
50886 if (!SWIG_IsOK(ecode2)) {
50887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
50888 }
50889 arg2 = static_cast< wxRelationship >(val2);
50890 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50891 if (!SWIG_IsOK(res3)) {
50892 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
50893 }
50894 arg3 = reinterpret_cast< wxWindow * >(argp3);
50895 ecode4 = SWIG_AsVal_int(obj3, &val4);
50896 if (!SWIG_IsOK(ecode4)) {
50897 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
50898 }
50899 arg4 = static_cast< wxEdge >(val4);
50900 if (obj4) {
50901 ecode5 = SWIG_AsVal_int(obj4, &val5);
50902 if (!SWIG_IsOK(ecode5)) {
50903 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
50904 }
50905 arg5 = static_cast< int >(val5);
50906 }
50907 if (obj5) {
50908 ecode6 = SWIG_AsVal_int(obj5, &val6);
50909 if (!SWIG_IsOK(ecode6)) {
50910 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
50911 }
50912 arg6 = static_cast< int >(val6);
50913 }
50914 {
50915 PyThreadState* __tstate = wxPyBeginAllowThreads();
50916 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
50917 wxPyEndAllowThreads(__tstate);
50918 if (PyErr_Occurred()) SWIG_fail;
50919 }
50920 resultobj = SWIG_Py_Void();
50921 return resultobj;
50922 fail:
50923 return NULL;
50924 }
50925
50926
50927 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50928 PyObject *resultobj = 0;
50929 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
50930 wxWindow *arg2 = (wxWindow *) 0 ;
50931 int arg3 = (int) 0 ;
50932 void *argp1 = 0 ;
50933 int res1 = 0 ;
50934 void *argp2 = 0 ;
50935 int res2 = 0 ;
50936 int val3 ;
50937 int ecode3 = 0 ;
50938 PyObject * obj0 = 0 ;
50939 PyObject * obj1 = 0 ;
50940 PyObject * obj2 = 0 ;
50941 char * kwnames[] = {
50942 (char *) "self",(char *) "sibling",(char *) "marg", NULL
50943 };
50944
50945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
50947 if (!SWIG_IsOK(res1)) {
50948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
50949 }
50950 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
50951 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50952 if (!SWIG_IsOK(res2)) {
50953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
50954 }
50955 arg2 = reinterpret_cast< wxWindow * >(argp2);
50956 if (obj2) {
50957 ecode3 = SWIG_AsVal_int(obj2, &val3);
50958 if (!SWIG_IsOK(ecode3)) {
50959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
50960 }
50961 arg3 = static_cast< int >(val3);
50962 }
50963 {
50964 PyThreadState* __tstate = wxPyBeginAllowThreads();
50965 (arg1)->LeftOf(arg2,arg3);
50966 wxPyEndAllowThreads(__tstate);
50967 if (PyErr_Occurred()) SWIG_fail;
50968 }
50969 resultobj = SWIG_Py_Void();
50970 return resultobj;
50971 fail:
50972 return NULL;
50973 }
50974
50975
50976 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50977 PyObject *resultobj = 0;
50978 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
50979 wxWindow *arg2 = (wxWindow *) 0 ;
50980 int arg3 = (int) 0 ;
50981 void *argp1 = 0 ;
50982 int res1 = 0 ;
50983 void *argp2 = 0 ;
50984 int res2 = 0 ;
50985 int val3 ;
50986 int ecode3 = 0 ;
50987 PyObject * obj0 = 0 ;
50988 PyObject * obj1 = 0 ;
50989 PyObject * obj2 = 0 ;
50990 char * kwnames[] = {
50991 (char *) "self",(char *) "sibling",(char *) "marg", NULL
50992 };
50993
50994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
50996 if (!SWIG_IsOK(res1)) {
50997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
50998 }
50999 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51000 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51001 if (!SWIG_IsOK(res2)) {
51002 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51003 }
51004 arg2 = reinterpret_cast< wxWindow * >(argp2);
51005 if (obj2) {
51006 ecode3 = SWIG_AsVal_int(obj2, &val3);
51007 if (!SWIG_IsOK(ecode3)) {
51008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51009 }
51010 arg3 = static_cast< int >(val3);
51011 }
51012 {
51013 PyThreadState* __tstate = wxPyBeginAllowThreads();
51014 (arg1)->RightOf(arg2,arg3);
51015 wxPyEndAllowThreads(__tstate);
51016 if (PyErr_Occurred()) SWIG_fail;
51017 }
51018 resultobj = SWIG_Py_Void();
51019 return resultobj;
51020 fail:
51021 return NULL;
51022 }
51023
51024
51025 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51026 PyObject *resultobj = 0;
51027 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51028 wxWindow *arg2 = (wxWindow *) 0 ;
51029 int arg3 = (int) 0 ;
51030 void *argp1 = 0 ;
51031 int res1 = 0 ;
51032 void *argp2 = 0 ;
51033 int res2 = 0 ;
51034 int val3 ;
51035 int ecode3 = 0 ;
51036 PyObject * obj0 = 0 ;
51037 PyObject * obj1 = 0 ;
51038 PyObject * obj2 = 0 ;
51039 char * kwnames[] = {
51040 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51041 };
51042
51043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51045 if (!SWIG_IsOK(res1)) {
51046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51047 }
51048 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51049 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51050 if (!SWIG_IsOK(res2)) {
51051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51052 }
51053 arg2 = reinterpret_cast< wxWindow * >(argp2);
51054 if (obj2) {
51055 ecode3 = SWIG_AsVal_int(obj2, &val3);
51056 if (!SWIG_IsOK(ecode3)) {
51057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51058 }
51059 arg3 = static_cast< int >(val3);
51060 }
51061 {
51062 PyThreadState* __tstate = wxPyBeginAllowThreads();
51063 (arg1)->Above(arg2,arg3);
51064 wxPyEndAllowThreads(__tstate);
51065 if (PyErr_Occurred()) SWIG_fail;
51066 }
51067 resultobj = SWIG_Py_Void();
51068 return resultobj;
51069 fail:
51070 return NULL;
51071 }
51072
51073
51074 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51075 PyObject *resultobj = 0;
51076 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51077 wxWindow *arg2 = (wxWindow *) 0 ;
51078 int arg3 = (int) 0 ;
51079 void *argp1 = 0 ;
51080 int res1 = 0 ;
51081 void *argp2 = 0 ;
51082 int res2 = 0 ;
51083 int val3 ;
51084 int ecode3 = 0 ;
51085 PyObject * obj0 = 0 ;
51086 PyObject * obj1 = 0 ;
51087 PyObject * obj2 = 0 ;
51088 char * kwnames[] = {
51089 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51090 };
51091
51092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51094 if (!SWIG_IsOK(res1)) {
51095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51096 }
51097 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51098 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51099 if (!SWIG_IsOK(res2)) {
51100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51101 }
51102 arg2 = reinterpret_cast< wxWindow * >(argp2);
51103 if (obj2) {
51104 ecode3 = SWIG_AsVal_int(obj2, &val3);
51105 if (!SWIG_IsOK(ecode3)) {
51106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51107 }
51108 arg3 = static_cast< int >(val3);
51109 }
51110 {
51111 PyThreadState* __tstate = wxPyBeginAllowThreads();
51112 (arg1)->Below(arg2,arg3);
51113 wxPyEndAllowThreads(__tstate);
51114 if (PyErr_Occurred()) SWIG_fail;
51115 }
51116 resultobj = SWIG_Py_Void();
51117 return resultobj;
51118 fail:
51119 return NULL;
51120 }
51121
51122
51123 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51124 PyObject *resultobj = 0;
51125 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51126 wxWindow *arg2 = (wxWindow *) 0 ;
51127 wxEdge arg3 ;
51128 int arg4 = (int) 0 ;
51129 void *argp1 = 0 ;
51130 int res1 = 0 ;
51131 void *argp2 = 0 ;
51132 int res2 = 0 ;
51133 int val3 ;
51134 int ecode3 = 0 ;
51135 int val4 ;
51136 int ecode4 = 0 ;
51137 PyObject * obj0 = 0 ;
51138 PyObject * obj1 = 0 ;
51139 PyObject * obj2 = 0 ;
51140 PyObject * obj3 = 0 ;
51141 char * kwnames[] = {
51142 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51143 };
51144
51145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51147 if (!SWIG_IsOK(res1)) {
51148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51149 }
51150 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51151 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51152 if (!SWIG_IsOK(res2)) {
51153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51154 }
51155 arg2 = reinterpret_cast< wxWindow * >(argp2);
51156 ecode3 = SWIG_AsVal_int(obj2, &val3);
51157 if (!SWIG_IsOK(ecode3)) {
51158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51159 }
51160 arg3 = static_cast< wxEdge >(val3);
51161 if (obj3) {
51162 ecode4 = SWIG_AsVal_int(obj3, &val4);
51163 if (!SWIG_IsOK(ecode4)) {
51164 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51165 }
51166 arg4 = static_cast< int >(val4);
51167 }
51168 {
51169 PyThreadState* __tstate = wxPyBeginAllowThreads();
51170 (arg1)->SameAs(arg2,arg3,arg4);
51171 wxPyEndAllowThreads(__tstate);
51172 if (PyErr_Occurred()) SWIG_fail;
51173 }
51174 resultobj = SWIG_Py_Void();
51175 return resultobj;
51176 fail:
51177 return NULL;
51178 }
51179
51180
51181 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51182 PyObject *resultobj = 0;
51183 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51184 wxWindow *arg2 = (wxWindow *) 0 ;
51185 wxEdge arg3 ;
51186 int arg4 ;
51187 void *argp1 = 0 ;
51188 int res1 = 0 ;
51189 void *argp2 = 0 ;
51190 int res2 = 0 ;
51191 int val3 ;
51192 int ecode3 = 0 ;
51193 int val4 ;
51194 int ecode4 = 0 ;
51195 PyObject * obj0 = 0 ;
51196 PyObject * obj1 = 0 ;
51197 PyObject * obj2 = 0 ;
51198 PyObject * obj3 = 0 ;
51199 char * kwnames[] = {
51200 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51201 };
51202
51203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51205 if (!SWIG_IsOK(res1)) {
51206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51207 }
51208 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51209 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51210 if (!SWIG_IsOK(res2)) {
51211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51212 }
51213 arg2 = reinterpret_cast< wxWindow * >(argp2);
51214 ecode3 = SWIG_AsVal_int(obj2, &val3);
51215 if (!SWIG_IsOK(ecode3)) {
51216 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51217 }
51218 arg3 = static_cast< wxEdge >(val3);
51219 ecode4 = SWIG_AsVal_int(obj3, &val4);
51220 if (!SWIG_IsOK(ecode4)) {
51221 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51222 }
51223 arg4 = static_cast< int >(val4);
51224 {
51225 PyThreadState* __tstate = wxPyBeginAllowThreads();
51226 (arg1)->PercentOf(arg2,arg3,arg4);
51227 wxPyEndAllowThreads(__tstate);
51228 if (PyErr_Occurred()) SWIG_fail;
51229 }
51230 resultobj = SWIG_Py_Void();
51231 return resultobj;
51232 fail:
51233 return NULL;
51234 }
51235
51236
51237 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51238 PyObject *resultobj = 0;
51239 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51240 int arg2 ;
51241 void *argp1 = 0 ;
51242 int res1 = 0 ;
51243 int val2 ;
51244 int ecode2 = 0 ;
51245 PyObject * obj0 = 0 ;
51246 PyObject * obj1 = 0 ;
51247 char * kwnames[] = {
51248 (char *) "self",(char *) "val", NULL
51249 };
51250
51251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51253 if (!SWIG_IsOK(res1)) {
51254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51255 }
51256 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51257 ecode2 = SWIG_AsVal_int(obj1, &val2);
51258 if (!SWIG_IsOK(ecode2)) {
51259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51260 }
51261 arg2 = static_cast< int >(val2);
51262 {
51263 PyThreadState* __tstate = wxPyBeginAllowThreads();
51264 (arg1)->Absolute(arg2);
51265 wxPyEndAllowThreads(__tstate);
51266 if (PyErr_Occurred()) SWIG_fail;
51267 }
51268 resultobj = SWIG_Py_Void();
51269 return resultobj;
51270 fail:
51271 return NULL;
51272 }
51273
51274
51275 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51276 PyObject *resultobj = 0;
51277 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51278 void *argp1 = 0 ;
51279 int res1 = 0 ;
51280 PyObject *swig_obj[1] ;
51281
51282 if (!args) SWIG_fail;
51283 swig_obj[0] = args;
51284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51285 if (!SWIG_IsOK(res1)) {
51286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51287 }
51288 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51289 {
51290 PyThreadState* __tstate = wxPyBeginAllowThreads();
51291 (arg1)->Unconstrained();
51292 wxPyEndAllowThreads(__tstate);
51293 if (PyErr_Occurred()) SWIG_fail;
51294 }
51295 resultobj = SWIG_Py_Void();
51296 return resultobj;
51297 fail:
51298 return NULL;
51299 }
51300
51301
51302 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51303 PyObject *resultobj = 0;
51304 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51305 void *argp1 = 0 ;
51306 int res1 = 0 ;
51307 PyObject *swig_obj[1] ;
51308
51309 if (!args) SWIG_fail;
51310 swig_obj[0] = args;
51311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51312 if (!SWIG_IsOK(res1)) {
51313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51314 }
51315 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51316 {
51317 PyThreadState* __tstate = wxPyBeginAllowThreads();
51318 (arg1)->AsIs();
51319 wxPyEndAllowThreads(__tstate);
51320 if (PyErr_Occurred()) SWIG_fail;
51321 }
51322 resultobj = SWIG_Py_Void();
51323 return resultobj;
51324 fail:
51325 return NULL;
51326 }
51327
51328
51329 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51330 PyObject *resultobj = 0;
51331 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51332 wxWindow *result = 0 ;
51333 void *argp1 = 0 ;
51334 int res1 = 0 ;
51335 PyObject *swig_obj[1] ;
51336
51337 if (!args) SWIG_fail;
51338 swig_obj[0] = args;
51339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51340 if (!SWIG_IsOK(res1)) {
51341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51342 }
51343 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51344 {
51345 PyThreadState* __tstate = wxPyBeginAllowThreads();
51346 result = (wxWindow *)(arg1)->GetOtherWindow();
51347 wxPyEndAllowThreads(__tstate);
51348 if (PyErr_Occurred()) SWIG_fail;
51349 }
51350 {
51351 resultobj = wxPyMake_wxObject(result, 0);
51352 }
51353 return resultobj;
51354 fail:
51355 return NULL;
51356 }
51357
51358
51359 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51360 PyObject *resultobj = 0;
51361 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51362 wxEdge result;
51363 void *argp1 = 0 ;
51364 int res1 = 0 ;
51365 PyObject *swig_obj[1] ;
51366
51367 if (!args) SWIG_fail;
51368 swig_obj[0] = args;
51369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51370 if (!SWIG_IsOK(res1)) {
51371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51372 }
51373 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51374 {
51375 PyThreadState* __tstate = wxPyBeginAllowThreads();
51376 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51377 wxPyEndAllowThreads(__tstate);
51378 if (PyErr_Occurred()) SWIG_fail;
51379 }
51380 resultobj = SWIG_From_int(static_cast< int >(result));
51381 return resultobj;
51382 fail:
51383 return NULL;
51384 }
51385
51386
51387 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51388 PyObject *resultobj = 0;
51389 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51390 wxEdge arg2 ;
51391 void *argp1 = 0 ;
51392 int res1 = 0 ;
51393 int val2 ;
51394 int ecode2 = 0 ;
51395 PyObject * obj0 = 0 ;
51396 PyObject * obj1 = 0 ;
51397 char * kwnames[] = {
51398 (char *) "self",(char *) "which", NULL
51399 };
51400
51401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51403 if (!SWIG_IsOK(res1)) {
51404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51405 }
51406 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51407 ecode2 = SWIG_AsVal_int(obj1, &val2);
51408 if (!SWIG_IsOK(ecode2)) {
51409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51410 }
51411 arg2 = static_cast< wxEdge >(val2);
51412 {
51413 PyThreadState* __tstate = wxPyBeginAllowThreads();
51414 (arg1)->SetEdge(arg2);
51415 wxPyEndAllowThreads(__tstate);
51416 if (PyErr_Occurred()) SWIG_fail;
51417 }
51418 resultobj = SWIG_Py_Void();
51419 return resultobj;
51420 fail:
51421 return NULL;
51422 }
51423
51424
51425 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51426 PyObject *resultobj = 0;
51427 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51428 int arg2 ;
51429 void *argp1 = 0 ;
51430 int res1 = 0 ;
51431 int val2 ;
51432 int ecode2 = 0 ;
51433 PyObject * obj0 = 0 ;
51434 PyObject * obj1 = 0 ;
51435 char * kwnames[] = {
51436 (char *) "self",(char *) "v", NULL
51437 };
51438
51439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51441 if (!SWIG_IsOK(res1)) {
51442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51443 }
51444 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51445 ecode2 = SWIG_AsVal_int(obj1, &val2);
51446 if (!SWIG_IsOK(ecode2)) {
51447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51448 }
51449 arg2 = static_cast< int >(val2);
51450 {
51451 PyThreadState* __tstate = wxPyBeginAllowThreads();
51452 (arg1)->SetValue(arg2);
51453 wxPyEndAllowThreads(__tstate);
51454 if (PyErr_Occurred()) SWIG_fail;
51455 }
51456 resultobj = SWIG_Py_Void();
51457 return resultobj;
51458 fail:
51459 return NULL;
51460 }
51461
51462
51463 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51464 PyObject *resultobj = 0;
51465 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51466 int result;
51467 void *argp1 = 0 ;
51468 int res1 = 0 ;
51469 PyObject *swig_obj[1] ;
51470
51471 if (!args) SWIG_fail;
51472 swig_obj[0] = args;
51473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51474 if (!SWIG_IsOK(res1)) {
51475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51476 }
51477 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51478 {
51479 PyThreadState* __tstate = wxPyBeginAllowThreads();
51480 result = (int)(arg1)->GetMargin();
51481 wxPyEndAllowThreads(__tstate);
51482 if (PyErr_Occurred()) SWIG_fail;
51483 }
51484 resultobj = SWIG_From_int(static_cast< int >(result));
51485 return resultobj;
51486 fail:
51487 return NULL;
51488 }
51489
51490
51491 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51492 PyObject *resultobj = 0;
51493 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51494 int arg2 ;
51495 void *argp1 = 0 ;
51496 int res1 = 0 ;
51497 int val2 ;
51498 int ecode2 = 0 ;
51499 PyObject * obj0 = 0 ;
51500 PyObject * obj1 = 0 ;
51501 char * kwnames[] = {
51502 (char *) "self",(char *) "m", NULL
51503 };
51504
51505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51507 if (!SWIG_IsOK(res1)) {
51508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51509 }
51510 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51511 ecode2 = SWIG_AsVal_int(obj1, &val2);
51512 if (!SWIG_IsOK(ecode2)) {
51513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51514 }
51515 arg2 = static_cast< int >(val2);
51516 {
51517 PyThreadState* __tstate = wxPyBeginAllowThreads();
51518 (arg1)->SetMargin(arg2);
51519 wxPyEndAllowThreads(__tstate);
51520 if (PyErr_Occurred()) SWIG_fail;
51521 }
51522 resultobj = SWIG_Py_Void();
51523 return resultobj;
51524 fail:
51525 return NULL;
51526 }
51527
51528
51529 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51530 PyObject *resultobj = 0;
51531 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51532 int result;
51533 void *argp1 = 0 ;
51534 int res1 = 0 ;
51535 PyObject *swig_obj[1] ;
51536
51537 if (!args) SWIG_fail;
51538 swig_obj[0] = args;
51539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51540 if (!SWIG_IsOK(res1)) {
51541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51542 }
51543 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51544 {
51545 PyThreadState* __tstate = wxPyBeginAllowThreads();
51546 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51547 wxPyEndAllowThreads(__tstate);
51548 if (PyErr_Occurred()) SWIG_fail;
51549 }
51550 resultobj = SWIG_From_int(static_cast< int >(result));
51551 return resultobj;
51552 fail:
51553 return NULL;
51554 }
51555
51556
51557 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51558 PyObject *resultobj = 0;
51559 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51560 int result;
51561 void *argp1 = 0 ;
51562 int res1 = 0 ;
51563 PyObject *swig_obj[1] ;
51564
51565 if (!args) SWIG_fail;
51566 swig_obj[0] = args;
51567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51568 if (!SWIG_IsOK(res1)) {
51569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51570 }
51571 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51572 {
51573 PyThreadState* __tstate = wxPyBeginAllowThreads();
51574 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51575 wxPyEndAllowThreads(__tstate);
51576 if (PyErr_Occurred()) SWIG_fail;
51577 }
51578 resultobj = SWIG_From_int(static_cast< int >(result));
51579 return resultobj;
51580 fail:
51581 return NULL;
51582 }
51583
51584
51585 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51586 PyObject *resultobj = 0;
51587 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51588 int result;
51589 void *argp1 = 0 ;
51590 int res1 = 0 ;
51591 PyObject *swig_obj[1] ;
51592
51593 if (!args) SWIG_fail;
51594 swig_obj[0] = args;
51595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51596 if (!SWIG_IsOK(res1)) {
51597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51598 }
51599 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51600 {
51601 PyThreadState* __tstate = wxPyBeginAllowThreads();
51602 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51603 wxPyEndAllowThreads(__tstate);
51604 if (PyErr_Occurred()) SWIG_fail;
51605 }
51606 resultobj = SWIG_From_int(static_cast< int >(result));
51607 return resultobj;
51608 fail:
51609 return NULL;
51610 }
51611
51612
51613 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51614 PyObject *resultobj = 0;
51615 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51616 bool result;
51617 void *argp1 = 0 ;
51618 int res1 = 0 ;
51619 PyObject *swig_obj[1] ;
51620
51621 if (!args) SWIG_fail;
51622 swig_obj[0] = args;
51623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51624 if (!SWIG_IsOK(res1)) {
51625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51626 }
51627 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51628 {
51629 PyThreadState* __tstate = wxPyBeginAllowThreads();
51630 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51631 wxPyEndAllowThreads(__tstate);
51632 if (PyErr_Occurred()) SWIG_fail;
51633 }
51634 {
51635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51636 }
51637 return resultobj;
51638 fail:
51639 return NULL;
51640 }
51641
51642
51643 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51644 PyObject *resultobj = 0;
51645 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51646 bool arg2 ;
51647 void *argp1 = 0 ;
51648 int res1 = 0 ;
51649 bool val2 ;
51650 int ecode2 = 0 ;
51651 PyObject * obj0 = 0 ;
51652 PyObject * obj1 = 0 ;
51653 char * kwnames[] = {
51654 (char *) "self",(char *) "d", NULL
51655 };
51656
51657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51659 if (!SWIG_IsOK(res1)) {
51660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51661 }
51662 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51663 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51664 if (!SWIG_IsOK(ecode2)) {
51665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51666 }
51667 arg2 = static_cast< bool >(val2);
51668 {
51669 PyThreadState* __tstate = wxPyBeginAllowThreads();
51670 (arg1)->SetDone(arg2);
51671 wxPyEndAllowThreads(__tstate);
51672 if (PyErr_Occurred()) SWIG_fail;
51673 }
51674 resultobj = SWIG_Py_Void();
51675 return resultobj;
51676 fail:
51677 return NULL;
51678 }
51679
51680
51681 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51682 PyObject *resultobj = 0;
51683 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51684 wxRelationship result;
51685 void *argp1 = 0 ;
51686 int res1 = 0 ;
51687 PyObject *swig_obj[1] ;
51688
51689 if (!args) SWIG_fail;
51690 swig_obj[0] = args;
51691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51692 if (!SWIG_IsOK(res1)) {
51693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51694 }
51695 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51696 {
51697 PyThreadState* __tstate = wxPyBeginAllowThreads();
51698 result = (wxRelationship)(arg1)->GetRelationship();
51699 wxPyEndAllowThreads(__tstate);
51700 if (PyErr_Occurred()) SWIG_fail;
51701 }
51702 resultobj = SWIG_From_int(static_cast< int >(result));
51703 return resultobj;
51704 fail:
51705 return NULL;
51706 }
51707
51708
51709 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51710 PyObject *resultobj = 0;
51711 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51712 wxRelationship arg2 ;
51713 void *argp1 = 0 ;
51714 int res1 = 0 ;
51715 int val2 ;
51716 int ecode2 = 0 ;
51717 PyObject * obj0 = 0 ;
51718 PyObject * obj1 = 0 ;
51719 char * kwnames[] = {
51720 (char *) "self",(char *) "r", NULL
51721 };
51722
51723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51725 if (!SWIG_IsOK(res1)) {
51726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51727 }
51728 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51729 ecode2 = SWIG_AsVal_int(obj1, &val2);
51730 if (!SWIG_IsOK(ecode2)) {
51731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51732 }
51733 arg2 = static_cast< wxRelationship >(val2);
51734 {
51735 PyThreadState* __tstate = wxPyBeginAllowThreads();
51736 (arg1)->SetRelationship(arg2);
51737 wxPyEndAllowThreads(__tstate);
51738 if (PyErr_Occurred()) SWIG_fail;
51739 }
51740 resultobj = SWIG_Py_Void();
51741 return resultobj;
51742 fail:
51743 return NULL;
51744 }
51745
51746
51747 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51748 PyObject *resultobj = 0;
51749 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51750 wxWindow *arg2 = (wxWindow *) 0 ;
51751 bool result;
51752 void *argp1 = 0 ;
51753 int res1 = 0 ;
51754 void *argp2 = 0 ;
51755 int res2 = 0 ;
51756 PyObject * obj0 = 0 ;
51757 PyObject * obj1 = 0 ;
51758 char * kwnames[] = {
51759 (char *) "self",(char *) "otherW", NULL
51760 };
51761
51762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
51763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51764 if (!SWIG_IsOK(res1)) {
51765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51766 }
51767 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51768 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51769 if (!SWIG_IsOK(res2)) {
51770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51771 }
51772 arg2 = reinterpret_cast< wxWindow * >(argp2);
51773 {
51774 PyThreadState* __tstate = wxPyBeginAllowThreads();
51775 result = (bool)(arg1)->ResetIfWin(arg2);
51776 wxPyEndAllowThreads(__tstate);
51777 if (PyErr_Occurred()) SWIG_fail;
51778 }
51779 {
51780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51781 }
51782 return resultobj;
51783 fail:
51784 return NULL;
51785 }
51786
51787
51788 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51789 PyObject *resultobj = 0;
51790 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51791 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
51792 wxWindow *arg3 = (wxWindow *) 0 ;
51793 bool result;
51794 void *argp1 = 0 ;
51795 int res1 = 0 ;
51796 void *argp2 = 0 ;
51797 int res2 = 0 ;
51798 void *argp3 = 0 ;
51799 int res3 = 0 ;
51800 PyObject * obj0 = 0 ;
51801 PyObject * obj1 = 0 ;
51802 PyObject * obj2 = 0 ;
51803 char * kwnames[] = {
51804 (char *) "self",(char *) "constraints",(char *) "win", NULL
51805 };
51806
51807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51809 if (!SWIG_IsOK(res1)) {
51810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51811 }
51812 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51813 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51814 if (!SWIG_IsOK(res2)) {
51815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
51816 }
51817 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
51818 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51819 if (!SWIG_IsOK(res3)) {
51820 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
51821 }
51822 arg3 = reinterpret_cast< wxWindow * >(argp3);
51823 {
51824 PyThreadState* __tstate = wxPyBeginAllowThreads();
51825 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
51826 wxPyEndAllowThreads(__tstate);
51827 if (PyErr_Occurred()) SWIG_fail;
51828 }
51829 {
51830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51831 }
51832 return resultobj;
51833 fail:
51834 return NULL;
51835 }
51836
51837
51838 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51839 PyObject *resultobj = 0;
51840 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51841 wxEdge arg2 ;
51842 wxWindow *arg3 = (wxWindow *) 0 ;
51843 wxWindow *arg4 = (wxWindow *) 0 ;
51844 int result;
51845 void *argp1 = 0 ;
51846 int res1 = 0 ;
51847 int val2 ;
51848 int ecode2 = 0 ;
51849 void *argp3 = 0 ;
51850 int res3 = 0 ;
51851 void *argp4 = 0 ;
51852 int res4 = 0 ;
51853 PyObject * obj0 = 0 ;
51854 PyObject * obj1 = 0 ;
51855 PyObject * obj2 = 0 ;
51856 PyObject * obj3 = 0 ;
51857 char * kwnames[] = {
51858 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
51859 };
51860
51861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51863 if (!SWIG_IsOK(res1)) {
51864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51865 }
51866 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51867 ecode2 = SWIG_AsVal_int(obj1, &val2);
51868 if (!SWIG_IsOK(ecode2)) {
51869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51870 }
51871 arg2 = static_cast< wxEdge >(val2);
51872 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51873 if (!SWIG_IsOK(res3)) {
51874 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
51875 }
51876 arg3 = reinterpret_cast< wxWindow * >(argp3);
51877 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
51878 if (!SWIG_IsOK(res4)) {
51879 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
51880 }
51881 arg4 = reinterpret_cast< wxWindow * >(argp4);
51882 {
51883 PyThreadState* __tstate = wxPyBeginAllowThreads();
51884 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
51885 wxPyEndAllowThreads(__tstate);
51886 if (PyErr_Occurred()) SWIG_fail;
51887 }
51888 resultobj = SWIG_From_int(static_cast< int >(result));
51889 return resultobj;
51890 fail:
51891 return NULL;
51892 }
51893
51894
51895 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51896 PyObject *obj;
51897 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51898 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
51899 return SWIG_Py_Void();
51900 }
51901
51902 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51903 PyObject *resultobj = 0;
51904 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
51905 wxIndividualLayoutConstraint *result = 0 ;
51906 void *argp1 = 0 ;
51907 int res1 = 0 ;
51908 PyObject *swig_obj[1] ;
51909
51910 if (!args) SWIG_fail;
51911 swig_obj[0] = args;
51912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51913 if (!SWIG_IsOK(res1)) {
51914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
51915 }
51916 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
51917 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
51918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51919 return resultobj;
51920 fail:
51921 return NULL;
51922 }
51923
51924
51925 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51926 PyObject *resultobj = 0;
51927 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
51928 wxIndividualLayoutConstraint *result = 0 ;
51929 void *argp1 = 0 ;
51930 int res1 = 0 ;
51931 PyObject *swig_obj[1] ;
51932
51933 if (!args) SWIG_fail;
51934 swig_obj[0] = args;
51935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51936 if (!SWIG_IsOK(res1)) {
51937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
51938 }
51939 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
51940 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
51941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51942 return resultobj;
51943 fail:
51944 return NULL;
51945 }
51946
51947
51948 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51949 PyObject *resultobj = 0;
51950 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
51951 wxIndividualLayoutConstraint *result = 0 ;
51952 void *argp1 = 0 ;
51953 int res1 = 0 ;
51954 PyObject *swig_obj[1] ;
51955
51956 if (!args) SWIG_fail;
51957 swig_obj[0] = args;
51958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51959 if (!SWIG_IsOK(res1)) {
51960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
51961 }
51962 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
51963 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
51964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51965 return resultobj;
51966 fail:
51967 return NULL;
51968 }
51969
51970
51971 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51972 PyObject *resultobj = 0;
51973 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
51974 wxIndividualLayoutConstraint *result = 0 ;
51975 void *argp1 = 0 ;
51976 int res1 = 0 ;
51977 PyObject *swig_obj[1] ;
51978
51979 if (!args) SWIG_fail;
51980 swig_obj[0] = args;
51981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51982 if (!SWIG_IsOK(res1)) {
51983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
51984 }
51985 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
51986 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
51987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51988 return resultobj;
51989 fail:
51990 return NULL;
51991 }
51992
51993
51994 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51995 PyObject *resultobj = 0;
51996 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
51997 wxIndividualLayoutConstraint *result = 0 ;
51998 void *argp1 = 0 ;
51999 int res1 = 0 ;
52000 PyObject *swig_obj[1] ;
52001
52002 if (!args) SWIG_fail;
52003 swig_obj[0] = args;
52004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52005 if (!SWIG_IsOK(res1)) {
52006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52007 }
52008 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52009 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52011 return resultobj;
52012 fail:
52013 return NULL;
52014 }
52015
52016
52017 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52018 PyObject *resultobj = 0;
52019 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52020 wxIndividualLayoutConstraint *result = 0 ;
52021 void *argp1 = 0 ;
52022 int res1 = 0 ;
52023 PyObject *swig_obj[1] ;
52024
52025 if (!args) SWIG_fail;
52026 swig_obj[0] = args;
52027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52028 if (!SWIG_IsOK(res1)) {
52029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52030 }
52031 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52032 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52034 return resultobj;
52035 fail:
52036 return NULL;
52037 }
52038
52039
52040 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52041 PyObject *resultobj = 0;
52042 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52043 wxIndividualLayoutConstraint *result = 0 ;
52044 void *argp1 = 0 ;
52045 int res1 = 0 ;
52046 PyObject *swig_obj[1] ;
52047
52048 if (!args) SWIG_fail;
52049 swig_obj[0] = args;
52050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52051 if (!SWIG_IsOK(res1)) {
52052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52053 }
52054 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52055 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52057 return resultobj;
52058 fail:
52059 return NULL;
52060 }
52061
52062
52063 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52064 PyObject *resultobj = 0;
52065 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52066 wxIndividualLayoutConstraint *result = 0 ;
52067 void *argp1 = 0 ;
52068 int res1 = 0 ;
52069 PyObject *swig_obj[1] ;
52070
52071 if (!args) SWIG_fail;
52072 swig_obj[0] = args;
52073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52074 if (!SWIG_IsOK(res1)) {
52075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52076 }
52077 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52078 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52080 return resultobj;
52081 fail:
52082 return NULL;
52083 }
52084
52085
52086 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52087 PyObject *resultobj = 0;
52088 wxLayoutConstraints *result = 0 ;
52089
52090 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52091 {
52092 PyThreadState* __tstate = wxPyBeginAllowThreads();
52093 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52094 wxPyEndAllowThreads(__tstate);
52095 if (PyErr_Occurred()) SWIG_fail;
52096 }
52097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52098 return resultobj;
52099 fail:
52100 return NULL;
52101 }
52102
52103
52104 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52105 PyObject *resultobj = 0;
52106 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52107 void *argp1 = 0 ;
52108 int res1 = 0 ;
52109 PyObject *swig_obj[1] ;
52110
52111 if (!args) SWIG_fail;
52112 swig_obj[0] = args;
52113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52114 if (!SWIG_IsOK(res1)) {
52115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52116 }
52117 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52118 {
52119 PyThreadState* __tstate = wxPyBeginAllowThreads();
52120 delete arg1;
52121
52122 wxPyEndAllowThreads(__tstate);
52123 if (PyErr_Occurred()) SWIG_fail;
52124 }
52125 resultobj = SWIG_Py_Void();
52126 return resultobj;
52127 fail:
52128 return NULL;
52129 }
52130
52131
52132 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52133 PyObject *resultobj = 0;
52134 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52135 wxWindow *arg2 = (wxWindow *) 0 ;
52136 int *arg3 = (int *) 0 ;
52137 bool result;
52138 void *argp1 = 0 ;
52139 int res1 = 0 ;
52140 void *argp2 = 0 ;
52141 int res2 = 0 ;
52142 int temp3 ;
52143 int res3 = SWIG_TMPOBJ ;
52144 PyObject * obj0 = 0 ;
52145 PyObject * obj1 = 0 ;
52146 char * kwnames[] = {
52147 (char *) "self",(char *) "win", NULL
52148 };
52149
52150 arg3 = &temp3;
52151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52153 if (!SWIG_IsOK(res1)) {
52154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52155 }
52156 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52157 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52158 if (!SWIG_IsOK(res2)) {
52159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52160 }
52161 arg2 = reinterpret_cast< wxWindow * >(argp2);
52162 {
52163 PyThreadState* __tstate = wxPyBeginAllowThreads();
52164 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52165 wxPyEndAllowThreads(__tstate);
52166 if (PyErr_Occurred()) SWIG_fail;
52167 }
52168 {
52169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52170 }
52171 if (SWIG_IsTmpObj(res3)) {
52172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52173 } else {
52174 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52176 }
52177 return resultobj;
52178 fail:
52179 return NULL;
52180 }
52181
52182
52183 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52184 PyObject *resultobj = 0;
52185 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52186 bool result;
52187 void *argp1 = 0 ;
52188 int res1 = 0 ;
52189 PyObject *swig_obj[1] ;
52190
52191 if (!args) SWIG_fail;
52192 swig_obj[0] = args;
52193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52194 if (!SWIG_IsOK(res1)) {
52195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52196 }
52197 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52198 {
52199 PyThreadState* __tstate = wxPyBeginAllowThreads();
52200 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52201 wxPyEndAllowThreads(__tstate);
52202 if (PyErr_Occurred()) SWIG_fail;
52203 }
52204 {
52205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52206 }
52207 return resultobj;
52208 fail:
52209 return NULL;
52210 }
52211
52212
52213 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52214 PyObject *obj;
52215 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52216 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52217 return SWIG_Py_Void();
52218 }
52219
52220 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52221 return SWIG_Python_InitShadowInstance(args);
52222 }
52223
52224 static PyMethodDef SwigMethods[] = {
52225 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52226 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
52227 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52228 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52229 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52230 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52231 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52232 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52233 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52234 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52235 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52236 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52237 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52238 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52239 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52240 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52241 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52242 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52243 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52244 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52245 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52246 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52247 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52248 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52249 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52250 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52251 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52252 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52253 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52254 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52255 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52256 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52257 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52258 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52259 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52260 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52261 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52262 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52263 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52264 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52265 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52266 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52267 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52268 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52269 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52270 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52271 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52272 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52273 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52274 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52275 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52276 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52277 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52278 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52279 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52280 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52281 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52282 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52283 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52284 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52285 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52286 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52287 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52288 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52289 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52290 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52291 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52292 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52293 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52294 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52295 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52296 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52297 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52298 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52299 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52300 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52301 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52302 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52303 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52304 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52305 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52306 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52307 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52308 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52309 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52310 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52311 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52312 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52313 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52314 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52315 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52316 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52317 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52318 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52319 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52320 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52321 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52322 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52323 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52324 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52325 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52326 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52327 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52328 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52329 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52330 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52331 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52332 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52333 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52334 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52335 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52336 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52337 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52338 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52339 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52340 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52341 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52342 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52343 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52344 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52345 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52346 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52347 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52348 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52349 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52350 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52351 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52352 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52353 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52354 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52355 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52356 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52357 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52358 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52359 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52360 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52361 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52362 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52363 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52364 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52365 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52366 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52367 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52368 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52369 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52370 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52371 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52372 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52373 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52374 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52375 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52376 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52377 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52378 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52379 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52380 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52381 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52382 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52383 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52384 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52385 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52386 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52387 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52388 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52389 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52390 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52391 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52392 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52393 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52394 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52395 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52396 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52397 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52398 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52399 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52400 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52401 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52402 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52403 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52404 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52405 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52406 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52407 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52408 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52409 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52410 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52411 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52412 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52413 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52414 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52415 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52416 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52417 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52418 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52419 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52420 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52421 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52422 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52423 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52424 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52425 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52426 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52427 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52428 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52429 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52430 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52431 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52432 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52433 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52434 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52435 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52436 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52437 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52438 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52439 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52440 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52441 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52442 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52443 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52444 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52445 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52446 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52447 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52448 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52449 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52450 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52451 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52452 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52453 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52454 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52455 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52456 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52457 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52458 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52459 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52460 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52461 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52462 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52463 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52464 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52465 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52466 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52467 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52468 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52469 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52470 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52471 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52472 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52473 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52474 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52475 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52476 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52477 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52478 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52479 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52480 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52481 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52482 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52483 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52484 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52485 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52486 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52487 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52488 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52489 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52490 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52491 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52492 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52493 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52494 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52495 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52496 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52497 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52498 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52499 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52500 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52501 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52502 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52503 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52504 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52505 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52506 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52507 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52508 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52509 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52510 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52511 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52512 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52513 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52514 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52515 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52516 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52517 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52518 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52519 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52520 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52521 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52522 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52523 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52524 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52525 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52526 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52527 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52528 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52529 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52530 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52531 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52532 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52533 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52534 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52535 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52536 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52537 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52538 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52539 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52540 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52541 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52542 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52543 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52544 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52545 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52546 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52547 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52548 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52549 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52550 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52551 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52552 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52553 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52554 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52555 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52556 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52557 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52558 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52560 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52561 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52562 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52563 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52564 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52565 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52566 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52567 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52568 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52569 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52570 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52571 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52572 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52573 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52574 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52575 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52576 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52577 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52578 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52579 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52580 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52581 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52582 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52583 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52584 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52585 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52586 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52587 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52588 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52589 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52590 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52591 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52592 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52593 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52594 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52595 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52596 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52597 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52598 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52599 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52600 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52601 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52602 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52603 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52604 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52605 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52606 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52607 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52608 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52609 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52610 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52611 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52612 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52613 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52614 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52615 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52616 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52617 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52618 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52620 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52621 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52623 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52624 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52625 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52626 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52627 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52628 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52629 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52630 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52631 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52632 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52633 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52634 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52636 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52637 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52638 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52639 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52640 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52641 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52642 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52643 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52644 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52645 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52646 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52647 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52648 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52649 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52650 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52651 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52653 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52655 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52656 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52657 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52658 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52659 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52660 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52661 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52662 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52663 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52664 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52665 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52666 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52667 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52668 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52669 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52670 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52671 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52672 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52673 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52674 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52675 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52677 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52678 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52679 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52681 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52682 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52683 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52684 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52685 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52686 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52688 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52692 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52693 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52694 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52695 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52696 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52697 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52698 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52699 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52700 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52701 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52702 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52703 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52704 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52705 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52706 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52707 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52708 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52709 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52710 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52711 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52712 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52713 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52714 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52715 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52716 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52717 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52718 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52719 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52720 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52721 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52722 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52723 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52724 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52725 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52726 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52727 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52728 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52729 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52730 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52731 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52732 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52733 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52734 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52735 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52736 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52737 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52738 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52739 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52740 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52741 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52742 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52743 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52744 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52745 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52746 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52747 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52748 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52749 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52750 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52751 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
52752 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
52753 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
52754 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
52755 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
52756 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
52757 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
52758 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
52760 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
52761 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
52762 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
52763 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
52764 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
52765 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
52766 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
52767 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
52768 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
52769 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
52770 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
52771 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
52772 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
52773 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
52774 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
52775 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
52776 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
52777 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
52778 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
52779 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
52780 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
52781 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
52782 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
52783 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
52784 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
52785 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
52786 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
52787 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
52788 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
52789 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
52790 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
52791 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
52792 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
52793 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
52794 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
52795 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
52796 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
52798 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
52799 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
52802 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
52803 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
52804 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
52805 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
52806 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
52807 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
52809 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
52810 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
52813 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
52814 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
52816 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
52817 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
52819 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
52820 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
52822 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
52823 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
52824 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
52826 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52827 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
52828 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
52829 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52830 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
52831 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
52832 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
52833 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52834 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
52835 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
52836 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
52837 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
52839 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
52840 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
52842 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
52843 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
52844 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
52845 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
52846 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
52849 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
52851 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
52853 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
52854 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
52855 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
52858 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
52859 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
52860 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
52862 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
52863 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
52864 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
52866 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
52867 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
52868 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
52869 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
52870 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
52871 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
52873 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
52874 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
52875 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
52876 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
52877 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
52878 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
52879 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
52880 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
52884 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
52886 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
52888 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
52890 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
52891 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
52892 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
52893 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
52894 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
52895 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52896 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
52897 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
52898 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
52899 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
52900 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
52901 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
52902 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52904 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
52905 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
52906 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
52907 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
52910 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
52911 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
52912 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
52913 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
52914 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
52916 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
52917 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
52918 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
52919 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
52921 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
52923 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
52924 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
52926 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
52927 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
52928 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52929 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
52930 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
52931 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
52932 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
52934 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
52936 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
52937 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
52938 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
52940 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
52942 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
52944 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
52945 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
52947 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
52949 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
52950 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
52951 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
52953 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52954 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
52955 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
52956 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
52957 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
52959 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
52961 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
52962 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
52963 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
52964 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
52966 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
52968 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
52970 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
52972 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
52973 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
52974 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
52975 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
52976 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
52977 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
52978 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
52979 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
52980 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
52981 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
52982 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
52983 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
52984 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
52986 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
52988 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
52989 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
52990 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
52991 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
52992 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
52994 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
52995 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
52996 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
52997 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
52998 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
52999 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53000 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53003 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53005 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53006 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53007 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53008 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53009 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53010 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53011 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53013 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53015 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53016 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53018 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53019 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53020 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53021 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53023 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53024 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53025 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53026 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53028 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53029 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53030 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53031 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53032 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53033 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53035 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53037 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53038 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53039 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53040 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53041 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53043 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53044 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53045 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53046 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53048 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53049 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53050 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53051 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53052 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53053 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53054 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53055 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53056 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53057 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53059 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53062 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53063 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53064 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53066 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53067 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53068 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53070 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53072 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53073 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53081 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53083 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53084 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53088 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53089 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53090 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53091 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53092 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53093 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53094 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53095 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53096 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53097 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53098 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53099 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53101 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53102 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53105 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53106 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53107 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53111 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53112 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53115 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53116 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53117 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53118 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53121 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53122 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53123 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53125 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53127 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53128 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53129 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53131 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53133 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53135 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53138 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53139 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53140 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53141 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53142 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53143 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53144 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53146 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53150 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53151 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53152 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53153 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53159 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53165 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53166 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53167 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53168 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53169 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53171 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53181 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53182 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53183 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53184 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53187 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53188 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53189 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53190 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53192 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53193 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53195 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53197 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53198 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53203 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53204 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53205 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53206 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53208 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53209 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53211 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53214 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53216 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53217 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53218 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53224 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53227 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53229 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53231 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53233 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53242 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53243 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53244 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53245 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53246 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53249 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53252 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53254 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53257 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53259 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53260 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53263 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53265 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53266 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53267 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53268 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53269 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53274 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53275 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53276 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53278 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53279 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53280 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53282 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53284 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53285 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53286 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53288 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53289 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53292 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53299 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53300 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53303 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53306 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53310 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53311 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53314 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53317 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53318 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53331 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53333 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53335 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53336 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53338 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53339 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53340 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53341 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53343 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53344 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53345 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53349 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53366 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53368 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53369 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53371 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53373 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53374 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53375 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53377 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53378 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53381 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53382 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53384 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53385 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53387 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53390 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53391 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53393 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53395 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53396 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53397 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53398 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53400 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53401 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53404 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53406 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53408 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53410 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53413 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53415 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53416 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53417 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53419 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53420 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53421 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53423 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53426 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53428 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53429 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53433 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53437 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53438 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53440 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53442 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53444 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53446 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53448 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53449 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53450 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53451 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53455 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53456 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53457 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53458 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53460 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53461 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53466 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53467 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53468 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53469 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53470 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53472 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53474 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53476 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53477 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53479 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53481 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53484 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53485 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53486 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53488 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53489 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53490 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53504 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53505 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53506 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53507 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53508 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53509 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53515 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53516 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53520 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53521 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53523 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53524 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53526 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53528 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53529 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53531 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53532 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53533 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53539 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53540 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53541 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53542 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53543 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53544 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53551 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53553 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53554 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53555 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53556 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53557 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53558 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53560 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53564 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53565 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53566 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53567 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53568 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53569 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53570 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53572 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53573 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53574 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53580 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53581 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53582 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53584 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53585 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53586 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53591 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53592 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53593 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53594 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53595 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53596 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53600 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53601 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53606 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53607 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53609 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53610 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53615 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53617 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53618 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53619 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53620 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53621 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53626 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53627 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53636 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53637 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53638 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53639 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53642 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53644 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53645 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53646 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53647 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53649 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53654 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53655 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53656 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53657 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53658 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53659 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53660 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53661 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53662 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53663 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53664 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53666 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53667 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53668 { NULL, NULL, 0, NULL }
53669 };
53670
53671
53672 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53673
53674 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53675 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53676 }
53677 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53678 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53679 }
53680 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53681 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53682 }
53683 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53684 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53685 }
53686 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53687 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53688 }
53689 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53690 return (void *)((wxSizer *) ((wxGridSizer *) x));
53691 }
53692 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53693 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53694 }
53695 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53696 return (void *)((wxSizer *) ((wxPySizer *) x));
53697 }
53698 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53699 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53700 }
53701 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53702 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53703 }
53704 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53705 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53706 }
53707 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53708 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53709 }
53710 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53711 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53712 }
53713 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53714 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53715 }
53716 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53717 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53718 }
53719 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53720 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53721 }
53722 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53723 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53724 }
53725 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53726 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53727 }
53728 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53729 return (void *)((wxEvent *) ((wxPyEvent *) x));
53730 }
53731 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53732 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53733 }
53734 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53735 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53736 }
53737 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53738 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53739 }
53740 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53741 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53742 }
53743 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53744 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53745 }
53746 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53747 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
53748 }
53749 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
53750 return (void *)((wxEvent *) ((wxActivateEvent *) x));
53751 }
53752 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
53753 return (void *)((wxEvent *) ((wxSizeEvent *) x));
53754 }
53755 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
53756 return (void *)((wxEvent *) ((wxMoveEvent *) x));
53757 }
53758 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
53759 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
53760 }
53761 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
53762 return (void *)((wxEvent *) ((wxPaintEvent *) x));
53763 }
53764 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
53765 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
53766 }
53767 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
53768 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
53769 }
53770 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
53771 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
53772 }
53773 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
53774 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
53775 }
53776 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
53777 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53778 }
53779 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
53780 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
53781 }
53782 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
53783 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
53784 }
53785 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
53786 return (void *)((wxEvent *) ((wxFocusEvent *) x));
53787 }
53788 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
53789 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
53790 }
53791 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
53792 return (void *)((wxEvent *) ((wxShowEvent *) x));
53793 }
53794 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
53795 return (void *)((wxEvent *) ((wxCommandEvent *) x));
53796 }
53797 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
53798 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
53799 }
53800 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
53801 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
53802 }
53803 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
53804 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
53805 }
53806 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
53807 return (void *)((wxEvent *) ((wxKeyEvent *) x));
53808 }
53809 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
53810 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
53811 }
53812 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
53813 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
53814 }
53815 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
53816 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
53817 }
53818 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
53819 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
53820 }
53821 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
53822 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
53823 }
53824 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
53825 return (void *)((wxControl *) ((wxControlWithItems *) x));
53826 }
53827 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
53828 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
53829 }
53830 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
53831 return (void *)((wxEvtHandler *) ((wxWindow *) x));
53832 }
53833 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
53834 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
53835 }
53836 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
53837 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
53838 }
53839 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
53840 return (void *)((wxEvtHandler *) ((wxValidator *) x));
53841 }
53842 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
53843 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
53844 }
53845 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
53846 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
53847 }
53848 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
53849 return (void *)((wxEvtHandler *) ((wxMenu *) x));
53850 }
53851 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
53852 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
53853 }
53854 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
53855 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
53856 }
53857 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
53858 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
53859 }
53860 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
53861 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
53862 }
53863 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
53864 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
53865 }
53866 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
53867 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
53868 }
53869 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
53870 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
53871 }
53872 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
53873 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
53874 }
53875 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
53876 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
53877 }
53878 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
53879 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
53880 }
53881 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
53882 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
53883 }
53884 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
53885 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
53886 }
53887 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
53888 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
53889 }
53890 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
53891 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
53892 }
53893 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
53894 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
53895 }
53896 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
53897 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
53898 }
53899 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
53900 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
53901 }
53902 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
53903 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
53904 }
53905 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
53906 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
53907 }
53908 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
53909 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
53910 }
53911 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
53912 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
53913 }
53914 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
53915 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
53916 }
53917 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
53918 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
53919 }
53920 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
53921 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
53922 }
53923 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
53924 return (void *)((wxObject *) ((wxSizerItem *) x));
53925 }
53926 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
53927 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
53928 }
53929 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
53930 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
53931 }
53932 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
53933 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
53934 }
53935 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
53936 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
53937 }
53938 static void *_p_wxSizerTo_p_wxObject(void *x) {
53939 return (void *)((wxObject *) ((wxSizer *) x));
53940 }
53941 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
53942 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53943 }
53944 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
53945 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
53946 }
53947 static void *_p_wxEventTo_p_wxObject(void *x) {
53948 return (void *)((wxObject *) ((wxEvent *) x));
53949 }
53950 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
53951 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
53952 }
53953 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
53954 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
53955 }
53956 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
53957 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
53958 }
53959 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
53960 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
53961 }
53962 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
53963 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
53964 }
53965 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
53966 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
53967 }
53968 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
53969 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
53970 }
53971 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
53972 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53973 }
53974 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
53975 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
53976 }
53977 static void *_p_wxControlTo_p_wxObject(void *x) {
53978 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
53979 }
53980 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
53981 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
53982 }
53983 static void *_p_wxFSFileTo_p_wxObject(void *x) {
53984 return (void *)((wxObject *) ((wxFSFile *) x));
53985 }
53986 static void *_p_wxPySizerTo_p_wxObject(void *x) {
53987 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
53988 }
53989 static void *_p_wxPyEventTo_p_wxObject(void *x) {
53990 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
53991 }
53992 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
53993 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
53994 }
53995 static void *_p_wxShowEventTo_p_wxObject(void *x) {
53996 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
53997 }
53998 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
53999 return (void *)((wxObject *) ((wxMenuItem *) x));
54000 }
54001 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54002 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54003 }
54004 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54005 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54006 }
54007 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54008 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54009 }
54010 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54011 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54012 }
54013 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54014 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54015 }
54016 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54017 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54018 }
54019 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54020 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54021 }
54022 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54023 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54024 }
54025 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54026 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54027 }
54028 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54029 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54030 }
54031 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54032 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54033 }
54034 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54035 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54036 }
54037 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54038 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54039 }
54040 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54041 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54042 }
54043 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54044 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54045 }
54046 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54047 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54048 }
54049 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54050 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54051 }
54052 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54053 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54054 }
54055 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54056 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54057 }
54058 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54059 return (void *)((wxObject *) ((wxImageHandler *) x));
54060 }
54061 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54062 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54063 }
54064 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54065 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54066 }
54067 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54068 return (void *)((wxObject *) ((wxEvtHandler *) x));
54069 }
54070 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54071 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54072 }
54073 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54074 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54075 }
54076 static void *_p_wxImageTo_p_wxObject(void *x) {
54077 return (void *)((wxObject *) ((wxImage *) x));
54078 }
54079 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54080 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54081 }
54082 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54083 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54084 }
54085 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54086 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54087 }
54088 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54089 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54090 }
54091 static void *_p_wxWindowTo_p_wxObject(void *x) {
54092 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54093 }
54094 static void *_p_wxMenuTo_p_wxObject(void *x) {
54095 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54096 }
54097 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54098 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54099 }
54100 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54101 return (void *)((wxObject *) ((wxFileSystem *) x));
54102 }
54103 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54104 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54105 }
54106 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54107 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54108 }
54109 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54110 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54111 }
54112 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54113 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54114 }
54115 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54116 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54117 }
54118 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54119 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54120 }
54121 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54122 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54123 }
54124 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54125 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54126 }
54127 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54128 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54129 }
54130 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54131 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54132 }
54133 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54134 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54135 }
54136 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54137 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54138 }
54139 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54140 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54141 }
54142 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54143 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54144 }
54145 static void *_p_wxControlTo_p_wxWindow(void *x) {
54146 return (void *)((wxWindow *) ((wxControl *) x));
54147 }
54148 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54149 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54150 }
54151 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54152 return (void *)((wxWindow *) ((wxMenuBar *) x));
54153 }
54154 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54155 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54156 }
54157 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54158 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54159 }
54160 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54161 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54162 }
54163 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54164 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54165 }
54166 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54167 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54168 }
54169 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54170 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54171 }
54172 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54173 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54174 }
54175 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54176 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54177 }
54178 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54179 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54180 }
54181 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54182 return (void *)((wxValidator *) ((wxPyValidator *) x));
54183 }
54184 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54185 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54186 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};
54187 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54188 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54189 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54190 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54191 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54192 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54193 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54194 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54195 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54196 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54197 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54198 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54199 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54200 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54201 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54202 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54203 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54204 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54205 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54206 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54207 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54208 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54209 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54210 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54211 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54212 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54213 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54214 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54215 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54216 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54217 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54218 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54219 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54220 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54221 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54222 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54223 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54224 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54225 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54226 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54227 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54228 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54229 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54230 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54231 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54232 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54233 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54234 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54235 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54236 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54237 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54238 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54239 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54240 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54241 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54242 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54243 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54244 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54245 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54246 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54247 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54248 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54249 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54250 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54251 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54252 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54253 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54254 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54255 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54256 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54257 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54258 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54259 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54260 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54261 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54262 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54263 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54264 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54265 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54266 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54267 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54268 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54269 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54270 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54271 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54272 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54273 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54274 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54275 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54276 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54277 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54278 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54279 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54280 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54281 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54282 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54283 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54284 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54285 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54286 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54287 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54288 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54289 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54290 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54291 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54292 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54293 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54294 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54295 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54296 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54297 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54298 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54299 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54300 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54301 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54302 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54303 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54304 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54305 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54306 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54307 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54308 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54309 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54310 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54311 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54312 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54313
54314 static swig_type_info *swig_type_initial[] = {
54315 &_swigt__p_buffer,
54316 &_swigt__p_char,
54317 &_swigt__p_form_ops_t,
54318 &_swigt__p_int,
54319 &_swigt__p_long,
54320 &_swigt__p_unsigned_char,
54321 &_swigt__p_unsigned_int,
54322 &_swigt__p_unsigned_long,
54323 &_swigt__p_wxANIHandler,
54324 &_swigt__p_wxAcceleratorEntry,
54325 &_swigt__p_wxAcceleratorTable,
54326 &_swigt__p_wxActivateEvent,
54327 &_swigt__p_wxAppTraits,
54328 &_swigt__p_wxArrayString,
54329 &_swigt__p_wxBMPHandler,
54330 &_swigt__p_wxBitmap,
54331 &_swigt__p_wxBoxSizer,
54332 &_swigt__p_wxButton,
54333 &_swigt__p_wxCURHandler,
54334 &_swigt__p_wxCaret,
54335 &_swigt__p_wxChildFocusEvent,
54336 &_swigt__p_wxCloseEvent,
54337 &_swigt__p_wxColour,
54338 &_swigt__p_wxCommandEvent,
54339 &_swigt__p_wxContextMenuEvent,
54340 &_swigt__p_wxControl,
54341 &_swigt__p_wxControlWithItems,
54342 &_swigt__p_wxCursor,
54343 &_swigt__p_wxDC,
54344 &_swigt__p_wxDateEvent,
54345 &_swigt__p_wxDateTime,
54346 &_swigt__p_wxDisplayChangedEvent,
54347 &_swigt__p_wxDropFilesEvent,
54348 &_swigt__p_wxDuplexMode,
54349 &_swigt__p_wxEraseEvent,
54350 &_swigt__p_wxEvent,
54351 &_swigt__p_wxEventLoop,
54352 &_swigt__p_wxEventLoopActivator,
54353 &_swigt__p_wxEvtHandler,
54354 &_swigt__p_wxFSFile,
54355 &_swigt__p_wxFileSystem,
54356 &_swigt__p_wxFileSystemHandler,
54357 &_swigt__p_wxFlexGridSizer,
54358 &_swigt__p_wxFocusEvent,
54359 &_swigt__p_wxFont,
54360 &_swigt__p_wxFrame,
54361 &_swigt__p_wxGBPosition,
54362 &_swigt__p_wxGBSizerItem,
54363 &_swigt__p_wxGBSpan,
54364 &_swigt__p_wxGIFHandler,
54365 &_swigt__p_wxGridBagSizer,
54366 &_swigt__p_wxGridSizer,
54367 &_swigt__p_wxICOHandler,
54368 &_swigt__p_wxIconizeEvent,
54369 &_swigt__p_wxIdleEvent,
54370 &_swigt__p_wxImage,
54371 &_swigt__p_wxImageHandler,
54372 &_swigt__p_wxImageHistogram,
54373 &_swigt__p_wxImage_HSVValue,
54374 &_swigt__p_wxImage_RGBValue,
54375 &_swigt__p_wxIndividualLayoutConstraint,
54376 &_swigt__p_wxInitDialogEvent,
54377 &_swigt__p_wxInputStream,
54378 &_swigt__p_wxInternetFSHandler,
54379 &_swigt__p_wxItemContainer,
54380 &_swigt__p_wxJPEGHandler,
54381 &_swigt__p_wxKeyEvent,
54382 &_swigt__p_wxLayoutConstraints,
54383 &_swigt__p_wxMaximizeEvent,
54384 &_swigt__p_wxMemoryFSHandler,
54385 &_swigt__p_wxMenu,
54386 &_swigt__p_wxMenuBar,
54387 &_swigt__p_wxMenuBarBase,
54388 &_swigt__p_wxMenuEvent,
54389 &_swigt__p_wxMenuItem,
54390 &_swigt__p_wxMouseCaptureChangedEvent,
54391 &_swigt__p_wxMouseEvent,
54392 &_swigt__p_wxMoveEvent,
54393 &_swigt__p_wxNavigationKeyEvent,
54394 &_swigt__p_wxNcPaintEvent,
54395 &_swigt__p_wxNotifyEvent,
54396 &_swigt__p_wxObject,
54397 &_swigt__p_wxOutputStream,
54398 &_swigt__p_wxPCXHandler,
54399 &_swigt__p_wxPNGHandler,
54400 &_swigt__p_wxPNMHandler,
54401 &_swigt__p_wxPaintEvent,
54402 &_swigt__p_wxPaletteChangedEvent,
54403 &_swigt__p_wxPaperSize,
54404 &_swigt__p_wxPoint,
54405 &_swigt__p_wxPoint2D,
54406 &_swigt__p_wxPropagateOnce,
54407 &_swigt__p_wxPropagationDisabler,
54408 &_swigt__p_wxPyApp,
54409 &_swigt__p_wxPyCommandEvent,
54410 &_swigt__p_wxPyDropTarget,
54411 &_swigt__p_wxPyEvent,
54412 &_swigt__p_wxPyFileSystemHandler,
54413 &_swigt__p_wxPyImageHandler,
54414 &_swigt__p_wxPyInputStream,
54415 &_swigt__p_wxPySizer,
54416 &_swigt__p_wxPyValidator,
54417 &_swigt__p_wxQuantize,
54418 &_swigt__p_wxQueryNewPaletteEvent,
54419 &_swigt__p_wxRealPoint,
54420 &_swigt__p_wxRect,
54421 &_swigt__p_wxRegion,
54422 &_swigt__p_wxScrollEvent,
54423 &_swigt__p_wxScrollWinEvent,
54424 &_swigt__p_wxSetCursorEvent,
54425 &_swigt__p_wxShowEvent,
54426 &_swigt__p_wxSize,
54427 &_swigt__p_wxSizeEvent,
54428 &_swigt__p_wxSizer,
54429 &_swigt__p_wxSizerItem,
54430 &_swigt__p_wxStaticBox,
54431 &_swigt__p_wxStaticBoxSizer,
54432 &_swigt__p_wxStdDialogButtonSizer,
54433 &_swigt__p_wxSysColourChangedEvent,
54434 &_swigt__p_wxTIFFHandler,
54435 &_swigt__p_wxToolTip,
54436 &_swigt__p_wxUpdateUIEvent,
54437 &_swigt__p_wxValidator,
54438 &_swigt__p_wxVisualAttributes,
54439 &_swigt__p_wxWindow,
54440 &_swigt__p_wxWindowCreateEvent,
54441 &_swigt__p_wxWindowDestroyEvent,
54442 &_swigt__p_wxXPMHandler,
54443 &_swigt__p_wxZipFSHandler,
54444 };
54445
54446 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54447 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54448 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54449 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54450 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54451 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54452 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54453 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54454 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54455 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54456 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54457 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54458 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54459 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54460 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}};
54461 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54462 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}};
54463 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54464 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}};
54465 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54466 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54467 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54468 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54469 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
54470 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54471 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}};
54472 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54473 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54474 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54475 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54476 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54477 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54478 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54479 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54480 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54481 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
54482 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54483 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54484 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}};
54485 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54486 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54487 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}};
54488 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}};
54489 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54490 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54491 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54492 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54493 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54494 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54495 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54496 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54497 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}};
54498 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}};
54499 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54500 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54501 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54502 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}};
54503 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54504 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54505 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54506 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54507 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54508 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54509 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54510 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}};
54511 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54512 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54513 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54514 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54515 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54516 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54517 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54518 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54519 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54520 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54521 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54522 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54523 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54524 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54525 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54526 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54527 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
54528 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54529 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54530 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54531 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54532 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54533 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54534 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54535 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54536 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54537 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54538 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54539 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54540 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54541 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54542 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54543 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54544 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54545 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54546 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54547 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54548 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54549 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54550 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54551 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54552 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54553 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54554 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54555 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54556 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54557 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54558 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54559 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}};
54560 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}};
54561 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54562 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54563 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54564 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54565 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54566 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54567 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54568 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}};
54569 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54570 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}};
54571 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54572 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54573 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54574 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54575
54576 static swig_cast_info *swig_cast_initial[] = {
54577 _swigc__p_buffer,
54578 _swigc__p_char,
54579 _swigc__p_form_ops_t,
54580 _swigc__p_int,
54581 _swigc__p_long,
54582 _swigc__p_unsigned_char,
54583 _swigc__p_unsigned_int,
54584 _swigc__p_unsigned_long,
54585 _swigc__p_wxANIHandler,
54586 _swigc__p_wxAcceleratorEntry,
54587 _swigc__p_wxAcceleratorTable,
54588 _swigc__p_wxActivateEvent,
54589 _swigc__p_wxAppTraits,
54590 _swigc__p_wxArrayString,
54591 _swigc__p_wxBMPHandler,
54592 _swigc__p_wxBitmap,
54593 _swigc__p_wxBoxSizer,
54594 _swigc__p_wxButton,
54595 _swigc__p_wxCURHandler,
54596 _swigc__p_wxCaret,
54597 _swigc__p_wxChildFocusEvent,
54598 _swigc__p_wxCloseEvent,
54599 _swigc__p_wxColour,
54600 _swigc__p_wxCommandEvent,
54601 _swigc__p_wxContextMenuEvent,
54602 _swigc__p_wxControl,
54603 _swigc__p_wxControlWithItems,
54604 _swigc__p_wxCursor,
54605 _swigc__p_wxDC,
54606 _swigc__p_wxDateEvent,
54607 _swigc__p_wxDateTime,
54608 _swigc__p_wxDisplayChangedEvent,
54609 _swigc__p_wxDropFilesEvent,
54610 _swigc__p_wxDuplexMode,
54611 _swigc__p_wxEraseEvent,
54612 _swigc__p_wxEvent,
54613 _swigc__p_wxEventLoop,
54614 _swigc__p_wxEventLoopActivator,
54615 _swigc__p_wxEvtHandler,
54616 _swigc__p_wxFSFile,
54617 _swigc__p_wxFileSystem,
54618 _swigc__p_wxFileSystemHandler,
54619 _swigc__p_wxFlexGridSizer,
54620 _swigc__p_wxFocusEvent,
54621 _swigc__p_wxFont,
54622 _swigc__p_wxFrame,
54623 _swigc__p_wxGBPosition,
54624 _swigc__p_wxGBSizerItem,
54625 _swigc__p_wxGBSpan,
54626 _swigc__p_wxGIFHandler,
54627 _swigc__p_wxGridBagSizer,
54628 _swigc__p_wxGridSizer,
54629 _swigc__p_wxICOHandler,
54630 _swigc__p_wxIconizeEvent,
54631 _swigc__p_wxIdleEvent,
54632 _swigc__p_wxImage,
54633 _swigc__p_wxImageHandler,
54634 _swigc__p_wxImageHistogram,
54635 _swigc__p_wxImage_HSVValue,
54636 _swigc__p_wxImage_RGBValue,
54637 _swigc__p_wxIndividualLayoutConstraint,
54638 _swigc__p_wxInitDialogEvent,
54639 _swigc__p_wxInputStream,
54640 _swigc__p_wxInternetFSHandler,
54641 _swigc__p_wxItemContainer,
54642 _swigc__p_wxJPEGHandler,
54643 _swigc__p_wxKeyEvent,
54644 _swigc__p_wxLayoutConstraints,
54645 _swigc__p_wxMaximizeEvent,
54646 _swigc__p_wxMemoryFSHandler,
54647 _swigc__p_wxMenu,
54648 _swigc__p_wxMenuBar,
54649 _swigc__p_wxMenuBarBase,
54650 _swigc__p_wxMenuEvent,
54651 _swigc__p_wxMenuItem,
54652 _swigc__p_wxMouseCaptureChangedEvent,
54653 _swigc__p_wxMouseEvent,
54654 _swigc__p_wxMoveEvent,
54655 _swigc__p_wxNavigationKeyEvent,
54656 _swigc__p_wxNcPaintEvent,
54657 _swigc__p_wxNotifyEvent,
54658 _swigc__p_wxObject,
54659 _swigc__p_wxOutputStream,
54660 _swigc__p_wxPCXHandler,
54661 _swigc__p_wxPNGHandler,
54662 _swigc__p_wxPNMHandler,
54663 _swigc__p_wxPaintEvent,
54664 _swigc__p_wxPaletteChangedEvent,
54665 _swigc__p_wxPaperSize,
54666 _swigc__p_wxPoint,
54667 _swigc__p_wxPoint2D,
54668 _swigc__p_wxPropagateOnce,
54669 _swigc__p_wxPropagationDisabler,
54670 _swigc__p_wxPyApp,
54671 _swigc__p_wxPyCommandEvent,
54672 _swigc__p_wxPyDropTarget,
54673 _swigc__p_wxPyEvent,
54674 _swigc__p_wxPyFileSystemHandler,
54675 _swigc__p_wxPyImageHandler,
54676 _swigc__p_wxPyInputStream,
54677 _swigc__p_wxPySizer,
54678 _swigc__p_wxPyValidator,
54679 _swigc__p_wxQuantize,
54680 _swigc__p_wxQueryNewPaletteEvent,
54681 _swigc__p_wxRealPoint,
54682 _swigc__p_wxRect,
54683 _swigc__p_wxRegion,
54684 _swigc__p_wxScrollEvent,
54685 _swigc__p_wxScrollWinEvent,
54686 _swigc__p_wxSetCursorEvent,
54687 _swigc__p_wxShowEvent,
54688 _swigc__p_wxSize,
54689 _swigc__p_wxSizeEvent,
54690 _swigc__p_wxSizer,
54691 _swigc__p_wxSizerItem,
54692 _swigc__p_wxStaticBox,
54693 _swigc__p_wxStaticBoxSizer,
54694 _swigc__p_wxStdDialogButtonSizer,
54695 _swigc__p_wxSysColourChangedEvent,
54696 _swigc__p_wxTIFFHandler,
54697 _swigc__p_wxToolTip,
54698 _swigc__p_wxUpdateUIEvent,
54699 _swigc__p_wxValidator,
54700 _swigc__p_wxVisualAttributes,
54701 _swigc__p_wxWindow,
54702 _swigc__p_wxWindowCreateEvent,
54703 _swigc__p_wxWindowDestroyEvent,
54704 _swigc__p_wxXPMHandler,
54705 _swigc__p_wxZipFSHandler,
54706 };
54707
54708
54709 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54710
54711 static swig_const_info swig_const_table[] = {
54712 {0, 0, 0, 0.0, 0, 0}};
54713
54714 #ifdef __cplusplus
54715 }
54716 #endif
54717 /* -----------------------------------------------------------------------------
54718 * Type initialization:
54719 * This problem is tough by the requirement that no dynamic
54720 * memory is used. Also, since swig_type_info structures store pointers to
54721 * swig_cast_info structures and swig_cast_info structures store pointers back
54722 * to swig_type_info structures, we need some lookup code at initialization.
54723 * The idea is that swig generates all the structures that are needed.
54724 * The runtime then collects these partially filled structures.
54725 * The SWIG_InitializeModule function takes these initial arrays out of
54726 * swig_module, and does all the lookup, filling in the swig_module.types
54727 * array with the correct data and linking the correct swig_cast_info
54728 * structures together.
54729 *
54730 * The generated swig_type_info structures are assigned staticly to an initial
54731 * array. We just loop though that array, and handle each type individually.
54732 * First we lookup if this type has been already loaded, and if so, use the
54733 * loaded structure instead of the generated one. Then we have to fill in the
54734 * cast linked list. The cast data is initially stored in something like a
54735 * two-dimensional array. Each row corresponds to a type (there are the same
54736 * number of rows as there are in the swig_type_initial array). Each entry in
54737 * a column is one of the swig_cast_info structures for that type.
54738 * The cast_initial array is actually an array of arrays, because each row has
54739 * a variable number of columns. So to actually build the cast linked list,
54740 * we find the array of casts associated with the type, and loop through it
54741 * adding the casts to the list. The one last trick we need to do is making
54742 * sure the type pointer in the swig_cast_info struct is correct.
54743 *
54744 * First off, we lookup the cast->type name to see if it is already loaded.
54745 * There are three cases to handle:
54746 * 1) If the cast->type has already been loaded AND the type we are adding
54747 * casting info to has not been loaded (it is in this module), THEN we
54748 * replace the cast->type pointer with the type pointer that has already
54749 * been loaded.
54750 * 2) If BOTH types (the one we are adding casting info to, and the
54751 * cast->type) are loaded, THEN the cast info has already been loaded by
54752 * the previous module so we just ignore it.
54753 * 3) Finally, if cast->type has not already been loaded, then we add that
54754 * swig_cast_info to the linked list (because the cast->type) pointer will
54755 * be correct.
54756 * ----------------------------------------------------------------------------- */
54757
54758 #ifdef __cplusplus
54759 extern "C" {
54760 #if 0
54761 } /* c-mode */
54762 #endif
54763 #endif
54764
54765 #if 0
54766 #define SWIGRUNTIME_DEBUG
54767 #endif
54768
54769 SWIGRUNTIME void
54770 SWIG_InitializeModule(void *clientdata) {
54771 size_t i;
54772 swig_module_info *module_head;
54773 static int init_run = 0;
54774
54775 clientdata = clientdata;
54776
54777 if (init_run) return;
54778 init_run = 1;
54779
54780 /* Initialize the swig_module */
54781 swig_module.type_initial = swig_type_initial;
54782 swig_module.cast_initial = swig_cast_initial;
54783
54784 /* Try and load any already created modules */
54785 module_head = SWIG_GetModule(clientdata);
54786 if (module_head) {
54787 swig_module.next = module_head->next;
54788 module_head->next = &swig_module;
54789 } else {
54790 /* This is the first module loaded */
54791 swig_module.next = &swig_module;
54792 SWIG_SetModule(clientdata, &swig_module);
54793 }
54794
54795 /* Now work on filling in swig_module.types */
54796 #ifdef SWIGRUNTIME_DEBUG
54797 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
54798 #endif
54799 for (i = 0; i < swig_module.size; ++i) {
54800 swig_type_info *type = 0;
54801 swig_type_info *ret;
54802 swig_cast_info *cast;
54803
54804 #ifdef SWIGRUNTIME_DEBUG
54805 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54806 #endif
54807
54808 /* if there is another module already loaded */
54809 if (swig_module.next != &swig_module) {
54810 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
54811 }
54812 if (type) {
54813 /* Overwrite clientdata field */
54814 #ifdef SWIGRUNTIME_DEBUG
54815 printf("SWIG_InitializeModule: found type %s\n", type->name);
54816 #endif
54817 if (swig_module.type_initial[i]->clientdata) {
54818 type->clientdata = swig_module.type_initial[i]->clientdata;
54819 #ifdef SWIGRUNTIME_DEBUG
54820 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
54821 #endif
54822 }
54823 } else {
54824 type = swig_module.type_initial[i];
54825 }
54826
54827 /* Insert casting types */
54828 cast = swig_module.cast_initial[i];
54829 while (cast->type) {
54830 /* Don't need to add information already in the list */
54831 ret = 0;
54832 #ifdef SWIGRUNTIME_DEBUG
54833 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
54834 #endif
54835 if (swig_module.next != &swig_module) {
54836 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
54837 #ifdef SWIGRUNTIME_DEBUG
54838 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
54839 #endif
54840 }
54841 if (ret) {
54842 if (type == swig_module.type_initial[i]) {
54843 #ifdef SWIGRUNTIME_DEBUG
54844 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
54845 #endif
54846 cast->type = ret;
54847 ret = 0;
54848 } else {
54849 /* Check for casting already in the list */
54850 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
54851 #ifdef SWIGRUNTIME_DEBUG
54852 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
54853 #endif
54854 if (!ocast) ret = 0;
54855 }
54856 }
54857
54858 if (!ret) {
54859 #ifdef SWIGRUNTIME_DEBUG
54860 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
54861 #endif
54862 if (type->cast) {
54863 type->cast->prev = cast;
54864 cast->next = type->cast;
54865 }
54866 type->cast = cast;
54867 }
54868 cast++;
54869 }
54870 /* Set entry in modules->types array equal to the type */
54871 swig_module.types[i] = type;
54872 }
54873 swig_module.types[i] = 0;
54874
54875 #ifdef SWIGRUNTIME_DEBUG
54876 printf("**** SWIG_InitializeModule: Cast List ******\n");
54877 for (i = 0; i < swig_module.size; ++i) {
54878 int j = 0;
54879 swig_cast_info *cast = swig_module.cast_initial[i];
54880 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54881 while (cast->type) {
54882 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
54883 cast++;
54884 ++j;
54885 }
54886 printf("---- Total casts: %d\n",j);
54887 }
54888 printf("**** SWIG_InitializeModule: Cast List ******\n");
54889 #endif
54890 }
54891
54892 /* This function will propagate the clientdata field of type to
54893 * any new swig_type_info structures that have been added into the list
54894 * of equivalent types. It is like calling
54895 * SWIG_TypeClientData(type, clientdata) a second time.
54896 */
54897 SWIGRUNTIME void
54898 SWIG_PropagateClientData(void) {
54899 size_t i;
54900 swig_cast_info *equiv;
54901 static int init_run = 0;
54902
54903 if (init_run) return;
54904 init_run = 1;
54905
54906 for (i = 0; i < swig_module.size; i++) {
54907 if (swig_module.types[i]->clientdata) {
54908 equiv = swig_module.types[i]->cast;
54909 while (equiv) {
54910 if (!equiv->converter) {
54911 if (equiv->type && !equiv->type->clientdata)
54912 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
54913 }
54914 equiv = equiv->next;
54915 }
54916 }
54917 }
54918 }
54919
54920 #ifdef __cplusplus
54921 #if 0
54922 {
54923 /* c-mode */
54924 #endif
54925 }
54926 #endif
54927
54928
54929
54930 #ifdef __cplusplus
54931 extern "C" {
54932 #endif
54933
54934 /* Python-specific SWIG API */
54935 #define SWIG_newvarlink() SWIG_Python_newvarlink()
54936 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
54937 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
54938
54939 /* -----------------------------------------------------------------------------
54940 * global variable support code.
54941 * ----------------------------------------------------------------------------- */
54942
54943 typedef struct swig_globalvar {
54944 char *name; /* Name of global variable */
54945 PyObject *(*get_attr)(void); /* Return the current value */
54946 int (*set_attr)(PyObject *); /* Set the value */
54947 struct swig_globalvar *next;
54948 } swig_globalvar;
54949
54950 typedef struct swig_varlinkobject {
54951 PyObject_HEAD
54952 swig_globalvar *vars;
54953 } swig_varlinkobject;
54954
54955 SWIGINTERN PyObject *
54956 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
54957 return PyString_FromString("<Swig global variables>");
54958 }
54959
54960 SWIGINTERN PyObject *
54961 swig_varlink_str(swig_varlinkobject *v) {
54962 PyObject *str = PyString_FromString("(");
54963 swig_globalvar *var;
54964 for (var = v->vars; var; var=var->next) {
54965 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
54966 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
54967 }
54968 PyString_ConcatAndDel(&str,PyString_FromString(")"));
54969 return str;
54970 }
54971
54972 SWIGINTERN int
54973 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
54974 PyObject *str = swig_varlink_str(v);
54975 fprintf(fp,"Swig global variables ");
54976 fprintf(fp,"%s\n", PyString_AsString(str));
54977 Py_DECREF(str);
54978 return 0;
54979 }
54980
54981 SWIGINTERN void
54982 swig_varlink_dealloc(swig_varlinkobject *v) {
54983 swig_globalvar *var = v->vars;
54984 while (var) {
54985 swig_globalvar *n = var->next;
54986 free(var->name);
54987 free(var);
54988 var = n;
54989 }
54990 }
54991
54992 SWIGINTERN PyObject *
54993 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
54994 PyObject *res = NULL;
54995 swig_globalvar *var = v->vars;
54996 while (var) {
54997 if (strcmp(var->name,n) == 0) {
54998 res = (*var->get_attr)();
54999 break;
55000 }
55001 var = var->next;
55002 }
55003 if (res == NULL && !PyErr_Occurred()) {
55004 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55005 }
55006 return res;
55007 }
55008
55009 SWIGINTERN int
55010 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55011 int res = 1;
55012 swig_globalvar *var = v->vars;
55013 while (var) {
55014 if (strcmp(var->name,n) == 0) {
55015 res = (*var->set_attr)(p);
55016 break;
55017 }
55018 var = var->next;
55019 }
55020 if (res == 1 && !PyErr_Occurred()) {
55021 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55022 }
55023 return res;
55024 }
55025
55026 SWIGINTERN PyTypeObject*
55027 swig_varlink_type(void) {
55028 static char varlink__doc__[] = "Swig var link object";
55029 static PyTypeObject varlink_type;
55030 static int type_init = 0;
55031 if (!type_init) {
55032 const PyTypeObject tmp
55033 = {
55034 PyObject_HEAD_INIT(NULL)
55035 0, /* Number of items in variable part (ob_size) */
55036 (char *)"swigvarlink", /* Type name (tp_name) */
55037 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55038 0, /* Itemsize (tp_itemsize) */
55039 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55040 (printfunc) swig_varlink_print, /* Print (tp_print) */
55041 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55042 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55043 0, /* tp_compare */
55044 (reprfunc) swig_varlink_repr, /* tp_repr */
55045 0, /* tp_as_number */
55046 0, /* tp_as_sequence */
55047 0, /* tp_as_mapping */
55048 0, /* tp_hash */
55049 0, /* tp_call */
55050 (reprfunc)swig_varlink_str, /* tp_str */
55051 0, /* tp_getattro */
55052 0, /* tp_setattro */
55053 0, /* tp_as_buffer */
55054 0, /* tp_flags */
55055 varlink__doc__, /* tp_doc */
55056 0, /* tp_traverse */
55057 0, /* tp_clear */
55058 0, /* tp_richcompare */
55059 0, /* tp_weaklistoffset */
55060 #if PY_VERSION_HEX >= 0x02020000
55061 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55062 #endif
55063 #if PY_VERSION_HEX >= 0x02030000
55064 0, /* tp_del */
55065 #endif
55066 #ifdef COUNT_ALLOCS
55067 0,0,0,0 /* tp_alloc -> tp_next */
55068 #endif
55069 };
55070 varlink_type = tmp;
55071 varlink_type.ob_type = &PyType_Type;
55072 type_init = 1;
55073 }
55074 return &varlink_type;
55075 }
55076
55077 /* Create a variable linking object for use later */
55078 SWIGINTERN PyObject *
55079 SWIG_Python_newvarlink(void) {
55080 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55081 if (result) {
55082 result->vars = 0;
55083 }
55084 return ((PyObject*) result);
55085 }
55086
55087 SWIGINTERN void
55088 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55089 swig_varlinkobject *v = (swig_varlinkobject *) p;
55090 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55091 if (gv) {
55092 size_t size = strlen(name)+1;
55093 gv->name = (char *)malloc(size);
55094 if (gv->name) {
55095 strncpy(gv->name,name,size);
55096 gv->get_attr = get_attr;
55097 gv->set_attr = set_attr;
55098 gv->next = v->vars;
55099 }
55100 }
55101 v->vars = gv;
55102 }
55103
55104 SWIGINTERN PyObject *
55105 SWIG_globals() {
55106 static PyObject *_SWIG_globals = 0;
55107 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55108 return _SWIG_globals;
55109 }
55110
55111 /* -----------------------------------------------------------------------------
55112 * constants/methods manipulation
55113 * ----------------------------------------------------------------------------- */
55114
55115 /* Install Constants */
55116 SWIGINTERN void
55117 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55118 PyObject *obj = 0;
55119 size_t i;
55120 for (i = 0; constants[i].type; ++i) {
55121 switch(constants[i].type) {
55122 case SWIG_PY_POINTER:
55123 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55124 break;
55125 case SWIG_PY_BINARY:
55126 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55127 break;
55128 default:
55129 obj = 0;
55130 break;
55131 }
55132 if (obj) {
55133 PyDict_SetItemString(d, constants[i].name, obj);
55134 Py_DECREF(obj);
55135 }
55136 }
55137 }
55138
55139 /* -----------------------------------------------------------------------------*/
55140 /* Fix SwigMethods to carry the callback ptrs when needed */
55141 /* -----------------------------------------------------------------------------*/
55142
55143 SWIGINTERN void
55144 SWIG_Python_FixMethods(PyMethodDef *methods,
55145 swig_const_info *const_table,
55146 swig_type_info **types,
55147 swig_type_info **types_initial) {
55148 size_t i;
55149 for (i = 0; methods[i].ml_name; ++i) {
55150 char *c = methods[i].ml_doc;
55151 if (c && (c = strstr(c, "swig_ptr: "))) {
55152 int j;
55153 swig_const_info *ci = 0;
55154 char *name = c + 10;
55155 for (j = 0; const_table[j].type; ++j) {
55156 if (strncmp(const_table[j].name, name,
55157 strlen(const_table[j].name)) == 0) {
55158 ci = &(const_table[j]);
55159 break;
55160 }
55161 }
55162 if (ci) {
55163 size_t shift = (ci->ptype) - types;
55164 swig_type_info *ty = types_initial[shift];
55165 size_t ldoc = (c - methods[i].ml_doc);
55166 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55167 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55168 if (ndoc) {
55169 char *buff = ndoc;
55170 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55171 if (ptr) {
55172 strncpy(buff, methods[i].ml_doc, ldoc);
55173 buff += ldoc;
55174 strncpy(buff, "swig_ptr: ", 10);
55175 buff += 10;
55176 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55177 methods[i].ml_doc = ndoc;
55178 }
55179 }
55180 }
55181 }
55182 }
55183 }
55184
55185 #ifdef __cplusplus
55186 }
55187 #endif
55188
55189 /* -----------------------------------------------------------------------------*
55190 * Partial Init method
55191 * -----------------------------------------------------------------------------*/
55192
55193 #ifdef __cplusplus
55194 extern "C"
55195 #endif
55196 SWIGEXPORT void SWIG_init(void) {
55197 PyObject *m, *d;
55198
55199 /* Fix SwigMethods to carry the callback ptrs when needed */
55200 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55201
55202 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55203 d = PyModule_GetDict(m);
55204
55205 SWIG_InitializeModule(0);
55206 SWIG_InstallConstants(d,swig_const_table);
55207
55208
55209
55210 #ifndef wxPyUSE_EXPORT
55211 // Make our API structure a CObject so other modules can import it
55212 // from this module.
55213 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55214 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55215 Py_XDECREF(cobj);
55216 #endif
55217
55218 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55219 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55220 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55221 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55222 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55223 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55224 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55225 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55226 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55227 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55228 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55229 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55230 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55231 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55232 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55233 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55234 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55235 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55236 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55237 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55238 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55239 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55240 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55241 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55242 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55243 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55244 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55245 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55246 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55247 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55248 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55249 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55250 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55251 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55252 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55253 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55254 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55255 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55256 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55257 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55258 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55259 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55260 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55261 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55262 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55263 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55264 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55265 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55266 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55267 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55268 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55269 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55270 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55271 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55272 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55273 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55274 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55275 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55276 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55277 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55278 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55279 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55280 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55281 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55282 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55283 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55284 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55285 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55286 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55287 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55288 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55289 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55290 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55291 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55292 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55293 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55294 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55295 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55296 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55297 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55298 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55299 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55300 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55301 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55302 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55303 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55304 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55305 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55306 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55307 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55308 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55309 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55310 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55311 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55312 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55313 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55314 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55315 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55316 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55317 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55318 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55319 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55320 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55321 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55322 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55323 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55324 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55325 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55326 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55327 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55328 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55329 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55330 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55331 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55332 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55333 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55334 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55335 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55336 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55337 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55338 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55339 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55340 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55341 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55342 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55343 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55344 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55345 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55346 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55347 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55348 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55349 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55350 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55351 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55352 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55353 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55354 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55355 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55356 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55357 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55358 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55359 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55360 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55361 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55362 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55363 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55364 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55365 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55366 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55367 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55368 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55369 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55370 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55371 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55372 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55373 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55374 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55375 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55376 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55377 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55378 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55379 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55380 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55381 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55382 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55383 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55384 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55385 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55386 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55387 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55388 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55389 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55390 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55391 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55392 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55393 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55394 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55395 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55396 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55397 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55398 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55399 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55400 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55401 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55402 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55403 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55404 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55405 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55406 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55407 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55408 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55409 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55410 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55411 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55412 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55413 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55414 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55415 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55416 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55417 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55418 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55419 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55420 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55421 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55422 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55423 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55424 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55425 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55426 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55427 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55428 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55429 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55430 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55431 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55432 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55433 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55434 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55435 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55436 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55437 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55438 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55439 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55440 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55441 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55442 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55443 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55444 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55445 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55446 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55447 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55448 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55449 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55450 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55451 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55452 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55453 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55454 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55455 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55456 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55457 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55458 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55459 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55460 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55461 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55462 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55463 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55464 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55465 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55466 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55467 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55468 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55469 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55470 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55471 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55472 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55473 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55474 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55475 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55476 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55477 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55478 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55479 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55480 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55481 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55482 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55483 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55484 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55485 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55486 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55487 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55488 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55489 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55490 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55491 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55492 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55493 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55494 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55495 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55496 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55497 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55498 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55499 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55500 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55501 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55502 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55503 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55504 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55505 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55506 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55507 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55508 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55509 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55510 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55511 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55512 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55513 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55514 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55515 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55516 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55517 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55518 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55519 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55520 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55521 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55522 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55523 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55524 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55525 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55526 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55527 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55528 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55529 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55530 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55531 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55532 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55533 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55534 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55535 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55536 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55537 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55538 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55539 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55540 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55541 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55542 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55543 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55544 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55545 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55546 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55547 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55548 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55549 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55550 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55551 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55552 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55553 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55554 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55555 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55556 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55557 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55558 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55559 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55560 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55561 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55562 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55563 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55564 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55565 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55566 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55567 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55568 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55569 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55570 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55571 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55572 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55573 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55574 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55575 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55576 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55577 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55578 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55579 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55580 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55581 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55582 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55583 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55584 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55585 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55586 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55587 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55588 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55589 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55590 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55591 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55592 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55593 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55594 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55595 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55596 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55597 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55598 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55599 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55600 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55601 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55602 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55603 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55604 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55605 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55606 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55607 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55608 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55609 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55610 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55611 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55612 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55613 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55614 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55615 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55616 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55617 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55618 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55619 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55620 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55621 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55622 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55623 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55624 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55625 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55626 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55627 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55628 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55629 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55630 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55631 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55632 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55633 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55634 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55635 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55636 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55637 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55638 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55639 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55640 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55641 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55642 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55643 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55644 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55645 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55646 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55647 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55648 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55649 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55650 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55651 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55652 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55653 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55654 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55655 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55656 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55657 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55658 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55659 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55660 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55661 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55662 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55663 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55664 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55665 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55666 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55667 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55668 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55669 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55670 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55671 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55672 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55673 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55674 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55675 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55676 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55677 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55678 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55679 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55680 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55681 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55682 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55683 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55684 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55685 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55686 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55687 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55688 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55689 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55690 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55691 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55692 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55693 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55694 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55695 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55696 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55697 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55698 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55699 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55700 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55701 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55702 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55703 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55704 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55705 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55706 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55707 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55708 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55709 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55710 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55711 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55712 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55713 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55714 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55715 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55716 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55717 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55718 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55719 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55720 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55721 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55722 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55723 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55724 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55725 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55726 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55727 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55728 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55729 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55730 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55731 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55732 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55733 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55734 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55735 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55736 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55737 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55738 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55739 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55740 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55741 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55742 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55743 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55744 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
55745 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
55746 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
55747 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
55748 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
55749 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
55750 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
55751 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
55752 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
55753 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
55754 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
55755 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
55756 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
55757 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
55758 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
55759 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
55760 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
55761 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
55762 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
55763 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
55764 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
55765 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
55766 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
55767 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
55768 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
55769 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
55770 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
55771 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
55772 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
55773 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
55774 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
55775 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
55776 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
55777 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
55778 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
55779 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
55780 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
55781 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
55782 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
55783 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
55784 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
55785 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
55786 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
55787 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
55788 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
55789 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
55790 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
55791 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
55792 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
55793 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
55794 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
55795 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
55796 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
55797 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
55798 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
55799 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
55800 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
55801 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
55802 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
55803 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
55804 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
55805 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
55806 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
55807 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
55808 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
55809 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
55810 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
55811 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
55812 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
55813 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
55814 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
55815 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
55816 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
55817 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
55818 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
55819 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
55820 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
55821 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
55822 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
55823 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
55824 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
55825 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
55826 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
55827 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
55828 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
55829 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
55830 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
55831 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
55832 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
55833 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
55834 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
55835 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
55836 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
55837 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
55838 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
55839 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
55840 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
55841 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
55842 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
55843 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
55844 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
55845 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
55846 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
55847 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
55848 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
55849 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
55850 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
55851 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
55852 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
55853 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
55854 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
55855 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
55856 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
55857 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
55858 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
55859 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
55860 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
55861 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
55862 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
55863 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
55864 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
55865 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
55866 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
55867 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
55868 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
55869 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
55870 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
55871 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
55872 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
55873 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
55874 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
55875 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
55876 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
55877 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
55878 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
55879 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
55880 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
55881 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
55882 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
55883 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
55884 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
55885 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
55886 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
55887
55888 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
55889
55890
55891 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
55892
55893 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
55894 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
55895 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
55896 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
55897 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
55898 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
55899 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
55900 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
55901 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
55902 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
55903 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
55904 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
55905 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
55906 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
55907 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
55908 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
55909 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
55910 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
55911 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
55912 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
55913 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
55914 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
55915 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
55916 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
55917 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
55918 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
55919 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
55920 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
55921 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
55922 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
55923 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
55924 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
55925 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
55926 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
55927 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
55928 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
55929 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
55930 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
55931 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
55932 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
55933 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
55934 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
55935 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
55936 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
55937 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
55938 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
55939 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
55940 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
55941 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
55942 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
55943 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
55944 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
55945 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
55946 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
55947 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
55948 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
55949 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
55950 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
55951 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
55952 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
55953 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
55954 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
55955 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
55956 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
55957 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
55958 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
55959 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
55960 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
55961 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
55962 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
55963 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
55964 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
55965 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
55966 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
55967 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
55968 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
55969 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
55970 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
55971 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
55972 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
55973 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
55974 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
55975 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
55976 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
55977 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
55978 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
55979 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
55980 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
55981 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
55982 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
55983 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
55984 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
55985 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
55986 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
55987 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
55988 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
55989 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
55990 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
55991 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
55992 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
55993 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
55994 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
55995 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
55996 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
55997 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
55998 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
55999 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56000 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56001 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56002 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56003 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56004 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56005 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56006 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56007 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56008 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56009 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56010 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56011 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56012 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56013 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56014 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56015 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56016 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56017 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56018 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56019 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56020 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56021 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56022 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56023 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56024 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56025 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56026 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56027 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56028 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56029 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56030 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56031 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56032 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56033 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56034 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56035 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56036 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56037 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56038 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56039 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56040 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56041 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56042 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56043 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56044 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56045 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56046 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56047 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56048 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56049 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56050 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56051 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56052 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56053 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56054 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56055 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56056 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56057 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56058 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56059 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56060 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56061 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56062 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56063 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56064 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56065 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56066 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56067 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56068 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56069 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56070 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56071 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56072 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56073 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56074 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56075 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56076 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56077 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56078 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56079 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56080 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56081 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56082 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56083 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56084 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56085 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56086 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56087 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56088 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56089 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56090 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56091 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56092 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56093 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56094 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56095 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56096 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56097
56098 // Initialize threading, some globals and such
56099 __wxPyPreStart(d);
56100
56101
56102 // Although these are defined in __version__ they need to be here too so
56103 // that an assert can be done to ensure that the wxPython and the wxWindows
56104 // versions match.
56105 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56106 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56107 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56108
56109 }
56110
wxWidgets (Impactor)